From 6c259563bf4875e0472a64f08603fa9382f6ccbe Mon Sep 17 00:00:00 2001 From: Vivien Nicolas Date: Thu, 30 Sep 2021 11:41:32 +0200 Subject: [PATCH] Rename ConfigureAttribute to SubscribeAttribute, remove isAnalog, and remove some dead code introduced in #9510 (#9913) * Rename ConfigureAttribute to SubscribeAttribute, remove isAnalog, and remove some dead code introduced in #9510 * Update generated content --- examples/chip-tool/templates/commands.zapt | 8 +- .../common/ClusterTestGeneration.js | 29 +- .../zap-templates/common/ClustersHelper.js | 1 - .../templates/app/CHIPClusters-src.zapt | 3 +- .../templates/app/CHIPClusters.zapt | 2 +- src/controller/python/chip-device-ctrl.py | 16 +- src/controller/python/chip/ChipDeviceCtrl.py | 8 +- .../python/chip/clusters/CHIPClusters.cpp | 174 ++++++------ .../python/chip/clusters/CHIPClusters.py | 256 +++++++++--------- .../templates/python-CHIPClusters-cpp.zapt | 6 +- .../templates/python-CHIPClusters-py.zapt | 16 +- .../python/test/test_scripts/base.py | 4 +- .../TemperatureSensorViewController.m | 2 +- .../CHIP/templates/CHIPClustersObjc-src.zapt | 4 +- .../CHIP/templates/CHIPClustersObjc.zapt | 2 +- .../CHIP/templates/partials/test_cluster.zapt | 2 +- .../testsuite/WaitForAttributeReport.zapt | 14 - .../CHIP/zap-generated/CHIPClustersObjc.h | 68 ++--- .../CHIP/zap-generated/CHIPClustersObjc.mm | 122 ++++----- .../Framework/CHIPTests/CHIPClustersTests.m | 2 +- .../zap-generated/cluster/Commands.h | 122 +++------ .../chip-tool/zap-generated/test/Commands.h | 2 +- .../zap-generated/CHIPClusters.cpp | 120 +++----- .../zap-generated/CHIPClusters.h | 86 +++--- .../pump-app/zap-generated/CHIPClusters.cpp | 16 +- .../pump-app/zap-generated/CHIPClusters.h | 12 +- .../zap-generated/CHIPClusters.cpp | 27 +- .../zap-generated/CHIPClusters.h | 20 +- 28 files changed, 487 insertions(+), 657 deletions(-) delete mode 100644 src/darwin/Framework/CHIP/templates/partials/testsuite/WaitForAttributeReport.zapt diff --git a/examples/chip-tool/templates/commands.zapt b/examples/chip-tool/templates/commands.zapt index a3d0edbf09e582..c1fd01a0c480b6 100644 --- a/examples/chip-tool/templates/commands.zapt +++ b/examples/chip-tool/templates/commands.zapt @@ -319,9 +319,6 @@ public: AddArgument("attr-name", "{{asDelimitedCommand (asUpperCamelCase name)}}"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - {{#if isAnalog}} - AddArgument("change", {{asTypeMinValue type}}, {{asTypeMaxValue type}}, &mChange); - {{/if}} ModelCommand::AddArguments(); } @@ -345,7 +342,7 @@ public: return err; } - return cluster.ConfigureAttribute{{asUpperCamelCase name}}(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval{{#if isAnalog}}, mChange{{/if}}); + return cluster.SubscribeAttribute{{asUpperCamelCase name}}(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } private: @@ -354,9 +351,6 @@ private: chip::Callback::Callback<{{chipCallback.name}}AttributeCallback> * onReportCallback = new chip::Callback::Callback<{{chipCallback.name}}AttributeCallback>(On{{chipCallback.name}}AttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - {{#if isAnalog}} - {{chipType}} mChange; - {{/if}} }; {{/if}} diff --git a/src/app/zap-templates/common/ClusterTestGeneration.js b/src/app/zap-templates/common/ClusterTestGeneration.js index c26bdfb1c062a6..fd4a88619ef10d 100644 --- a/src/app/zap-templates/common/ClusterTestGeneration.js +++ b/src/app/zap-templates/common/ClusterTestGeneration.js @@ -76,7 +76,7 @@ function setDefaultType(test) break; case 'subscribeAttribute': - test.commandName = 'Configure'; + test.commandName = 'Subscribe'; test.isAttribute = true; test.isSubscribeAttribute = true; break; @@ -342,14 +342,6 @@ function isTestOnlyCluster(name) return name == DelayCommands.name; } -function chip_tests_with_command_attribute_info(options) -{ - const promise = assertCommandOrAttribute(this).then(item => { - return [ item ]; - }); - return asBlocks.call(this, promise, options); -} - function chip_tests_item_parameters(options) { const commandValues = this.arguments.values; @@ -425,20 +417,11 @@ function chip_tests_item_response_parameters(options) return asBlocks.call(this, promise, options); } -function chip_tests_WaitForAttributeReport_attribute_info(options) -{ - const waitfor = Object.assign(JSON.parse(JSON.stringify(this.waitfor)), { command : 'readAttribute', isAttribute : true }); - setDefaults(waitfor, this.parent); - return templateUtil.collectBlocks([ waitfor ], options, this); -} - // // Module exports // -exports.chip_tests = chip_tests; -exports.chip_tests_items = chip_tests_items; -exports.chip_tests_item_parameters = chip_tests_item_parameters; -exports.chip_tests_item_response_parameters = chip_tests_item_response_parameters; -exports.isTestOnlyCluster = isTestOnlyCluster; -exports.chip_tests_with_command_attribute_info = chip_tests_with_command_attribute_info; -exports.chip_tests_WaitForAttributeReport_attribute_info = chip_tests_WaitForAttributeReport_attribute_info; +exports.chip_tests = chip_tests; +exports.chip_tests_items = chip_tests_items; +exports.chip_tests_item_parameters = chip_tests_item_parameters; +exports.chip_tests_item_response_parameters = chip_tests_item_response_parameters; +exports.isTestOnlyCluster = isTestOnlyCluster; diff --git a/src/app/zap-templates/common/ClustersHelper.js b/src/app/zap-templates/common/ClustersHelper.js index 7e68fed44a8ce5..64ebf2768f62a0 100644 --- a/src/app/zap-templates/common/ClustersHelper.js +++ b/src/app/zap-templates/common/ClustersHelper.js @@ -313,7 +313,6 @@ function handleBasic(item, [ atomics, enums, bitmaps, structs ]) item.name = item.name || item.label; item.isStruct = false; item.atomicTypeId = atomic.atomicId; - item.isAnalog = atomic.isDiscrete == false && atomic.isString == false; item.size = atomic.size; item.chipType = atomic.chipType; item.chipTypePutLength = asPutLength(atomic.chipType); diff --git a/src/app/zap-templates/templates/app/CHIPClusters-src.zapt b/src/app/zap-templates/templates/app/CHIPClusters-src.zapt index d9239f0358da46..fe2e0e9a62181c 100644 --- a/src/app/zap-templates/templates/app/CHIPClusters-src.zapt +++ b/src/app/zap-templates/templates/app/CHIPClusters-src.zapt @@ -111,9 +111,8 @@ CHIP_ERROR {{asUpperCamelCase parent.name}}Cluster::WriteAttribute{{asUpperCamel {{/if}} {{#if isReportableAttribute}} -CHIP_ERROR {{asUpperCamelCase parent.name}}Cluster::ConfigureAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval{{#if isAnalog}}, {{chipType}} change{{/if}}) +CHIP_ERROR {{asUpperCamelCase parent.name}}Cluster::SubscribeAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - {{#if isAnalog}}IgnoreUnusedVariable(change);{{/if}} chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; diff --git a/src/app/zap-templates/templates/app/CHIPClusters.zapt b/src/app/zap-templates/templates/app/CHIPClusters.zapt index 3ee75d9c6da3db..4cce659bd38ea0 100644 --- a/src/app/zap-templates/templates/app/CHIPClusters.zapt +++ b/src/app/zap-templates/templates/app/CHIPClusters.zapt @@ -39,7 +39,7 @@ public: {{/chip_server_cluster_attributes}} {{#chip_server_cluster_attributes}} {{#if isReportableAttribute}} - CHIP_ERROR ConfigureAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval{{#if isAnalog}}, {{chipType}} change{{/if}}); + 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); {{/if}} {{/chip_server_cluster_attributes}} diff --git a/src/controller/python/chip-device-ctrl.py b/src/controller/python/chip-device-ctrl.py index 2b395019dd4008..d3e737574fce37 100755 --- a/src/controller/python/chip-device-ctrl.py +++ b/src/controller/python/chip-device-ctrl.py @@ -202,7 +202,7 @@ def __init__(self, rendezvousAddr=None, controllerNodeId=0, bluetoothAdapter=Non "resolve", "zcl", "zclread", - "zclconfigure", + "zclsubscribe", "discover", @@ -805,10 +805,10 @@ def do_zclwrite(self, line): print("An exception occurred during processing input:") print(str(ex)) - def do_zclconfigure(self, line): + def do_zclsubscribe(self, line): """ - To configure ZCL attribute reporting: - zclconfigure + To subscribe ZCL attribute reporting: + zclsubscribe """ try: args = shlex.split(line) @@ -821,13 +821,13 @@ def do_zclconfigure(self, line): cluster_attrs = all_attrs.get(args[1], {}) print('\n'.join([key for key in cluster_attrs.keys( ) if cluster_attrs[key].get("reportable", False)])) - elif len(args) == 7: + elif len(args) == 6: if args[0] not in all_attrs: raise exceptions.UnknownCluster(args[0]) - self.devCtrl.ZCLConfigureAttribute(args[0], args[1], int( - args[2]), int(args[3]), int(args[4]), int(args[5]), int(args[6])) + self.devCtrl.ZCLSubscribeAttribute(args[0], args[1], int( + args[2]), int(args[3]), int(args[4]), int(args[5])) else: - self.do_help("zclconfigure") + self.do_help("zclsubscribe") except exceptions.ChipStackException as ex: print("An exception occurred during configuring reporting of ZCL attribute:") print(str(ex)) diff --git a/src/controller/python/chip/ChipDeviceCtrl.py b/src/controller/python/chip/ChipDeviceCtrl.py index 5ebeaea2712508..1809d65db49257 100644 --- a/src/controller/python/chip/ChipDeviceCtrl.py +++ b/src/controller/python/chip/ChipDeviceCtrl.py @@ -350,10 +350,10 @@ def ZCLWriteAttribute(self, cluster, attribute, nodeid, endpoint, groupid, value if blocking: return im.GetAttributeWriteResponse(im.DEFAULT_ATTRIBUTEWRITE_APPID) - def ZCLConfigureAttribute(self, cluster, attribute, nodeid, endpoint, minInterval, maxInterval, change, blocking=True): + def ZCLSubscribeAttribute(self, cluster, attribute, nodeid, endpoint, minInterval, maxInterval, blocking=True): device = c_void_p(None) # We should really use pychip_GetConnectedDeviceByNodeId and do the - # ConfigureAttribute off its callback.... + # SubscribeAttribute off its callback.... res = self._ChipStack.Call(lambda: self._dmLib.pychip_GetDeviceByNodeId( self.devCtrl, nodeid, pointer(device))) if res != 0: @@ -361,8 +361,8 @@ def ZCLConfigureAttribute(self, cluster, attribute, nodeid, endpoint, minInterva commandSenderHandle = self._dmLib.pychip_GetCommandSenderHandle(device) im.ClearCommandStatus(commandSenderHandle) - res = self._Cluster.ConfigureAttribute( - device, cluster, attribute, endpoint, minInterval, maxInterval, change, commandSenderHandle != 0) + res = self._Cluster.SubscribeAttribute( + device, cluster, attribute, endpoint, minInterval, maxInterval, commandSenderHandle != 0) if blocking: # We only send 1 command by this function, so index is always 0 return im.WaitCommandIndexStatus(commandSenderHandle, 1) diff --git a/src/controller/python/chip/clusters/CHIPClusters.cpp b/src/controller/python/chip/clusters/CHIPClusters.cpp index c823eca0e2a48b..c49be9fdabcd59 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.cpp +++ b/src/controller/python/chip/clusters/CHIPClusters.cpp @@ -978,7 +978,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_BinaryInputBasic_PresentValu return cluster.ReadAttributePresentValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_BinaryInputBasic_PresentValue(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_BinaryInputBasic_PresentValue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { @@ -986,7 +986,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_BinaryInputBasic_Presen chip::Controller::BinaryInputBasicCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributePresentValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + .SubscribeAttributePresentValue(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -1011,7 +1011,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_BinaryInputBasic_StatusFlags return cluster.ReadAttributeStatusFlags(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_BinaryInputBasic_StatusFlags(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_BinaryInputBasic_StatusFlags(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { @@ -1019,7 +1019,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_BinaryInputBasic_Status chip::Controller::BinaryInputBasicCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeStatusFlags(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) + .SubscribeAttributeStatusFlags(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -1451,17 +1451,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentHue(chip return cluster.ReadAttributeCurrentHue(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_ColorControl_CurrentHue(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentHue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, - uint16_t minInterval, uint16_t maxInterval, - uint8_t change) + uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::ColorControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentHue(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval, - change) + .SubscribeAttributeCurrentHue(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -1475,17 +1473,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentSaturati return cluster.ReadAttributeCurrentSaturation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_ColorControl_CurrentSaturation(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentSaturation(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, - uint16_t minInterval, uint16_t maxInterval, - uint8_t change) + uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::ColorControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentSaturation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeCurrentSaturation(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -1509,16 +1506,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentX(chip:: return cluster.ReadAttributeCurrentX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_ColorControl_CurrentX(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentX(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, - uint16_t maxInterval, uint16_t change) + uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::ColorControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval, - change) + .SubscribeAttributeCurrentX(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -1532,16 +1528,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_CurrentY(chip:: return cluster.ReadAttributeCurrentY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_ColorControl_CurrentY(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_CurrentY(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, - uint16_t maxInterval, uint16_t change) + uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::ColorControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval, - change) + .SubscribeAttributeCurrentY(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -1576,17 +1571,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_ColorControl_ColorTemperatur return cluster.ReadAttributeColorTemperature(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_ColorControl_ColorTemperature(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_ColorControl_ColorTemperature(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, - uint16_t minInterval, uint16_t maxInterval, - uint16_t change) + uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::ColorControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeColorTemperature(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeColorTemperature(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -2540,7 +2534,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_DoorLock_LockState(chip::Con return cluster.ReadAttributeLockState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_DoorLock_LockState(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_DoorLock_LockState(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { @@ -2548,7 +2542,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_DoorLock_LockState(chip chip::Controller::DoorLockCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeLockState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) + .SubscribeAttributeLockState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -3265,17 +3259,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_LevelControl_CurrentLevel(ch return cluster.ReadAttributeCurrentLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_LevelControl_CurrentLevel(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_LevelControl_CurrentLevel(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, - uint16_t minInterval, uint16_t maxInterval, - uint8_t change) + uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::LevelControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeCurrentLevel(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -3805,7 +3798,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_OccupancySensing_Occupancy(c return cluster.ReadAttributeOccupancy(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_OccupancySensing_Occupancy(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_OccupancySensing_Occupancy(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { @@ -3813,7 +3806,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_OccupancySensing_Occupa chip::Controller::OccupancySensingCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeOccupancy(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) + .SubscribeAttributeOccupancy(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -3912,7 +3905,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_OnOff_OnOff(chip::Controller return cluster.ReadAttributeOnOff(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_OnOff_OnOff(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_OnOff_OnOff(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { @@ -3920,7 +3913,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_OnOff_OnOff(chip::Contr chip::Controller::OnOffCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeOnOff(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) + .SubscribeAttributeOnOff(gBooleanAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -4323,17 +4316,17 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_PressureMeasurement_Measured return cluster.ReadAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_PressureMeasurement_MeasuredValue(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_PressureMeasurement_MeasuredValue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, - uint16_t maxInterval, int16_t change) + uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::PressureMeasurementCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -4430,17 +4423,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_PumpConfigurationAndControl_ return cluster.ReadAttributeCapacity(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_PumpConfigurationAndControl_Capacity(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_PumpConfigurationAndControl_Capacity(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, - uint16_t maxInterval, int16_t change) + uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::PumpConfigurationAndControlCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCapacity(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval, - change) + .SubscribeAttributeCapacity(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -4487,15 +4479,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_RelativeHumidityMeasurement_ return cluster.ReadAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_RelativeHumidityMeasurement_MeasuredValue( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint16_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_RelativeHumidityMeasurement_MeasuredValue( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::RelativeHumidityMeasurementCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeMeasuredValue(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -4738,17 +4730,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_Switch_CurrentPosition(chip: return cluster.ReadAttributeCurrentPosition(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_Switch_CurrentPosition(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_Switch_CurrentPosition(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, - uint16_t minInterval, uint16_t maxInterval, - uint8_t change) + uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::SwitchCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentPosition(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeCurrentPosition(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -4887,17 +4878,17 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_TemperatureMeasurement_Measu return cluster.ReadAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_TemperatureMeasurement_MeasuredValue(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_TemperatureMeasurement_MeasuredValue(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, - uint16_t maxInterval, int16_t change) + uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::TemperatureMeasurementCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeMeasuredValue(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -5508,17 +5499,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_Thermostat_LocalTemperature( return cluster.ReadAttributeLocalTemperature(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_Thermostat_LocalTemperature(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_Thermostat_LocalTemperature(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, - uint16_t minInterval, uint16_t maxInterval, - int16_t change) + uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::ThermostatCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeLocalTemperature(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, - maxInterval, change) + .SubscribeAttributeLocalTemperature(gInt16sAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + maxInterval) .AsInteger(); } @@ -6741,15 +6731,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositi .AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercentage( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint8_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercentage( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentPositionLiftPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), - minInterval, maxInterval, change) + .SubscribeAttributeCurrentPositionLiftPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), + minInterval, maxInterval) .AsInteger(); } @@ -6764,15 +6754,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositi .AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercentage( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint8_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercentage( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentPositionTiltPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), - minInterval, maxInterval, change) + .SubscribeAttributeCurrentPositionTiltPercentage(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), + minInterval, maxInterval) .AsInteger(); } @@ -6786,7 +6776,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_OperationalSt return cluster.ReadAttributeOperationalStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_OperationalStatus(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_OperationalStatus(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) @@ -6795,7 +6785,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_Operatio chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeOperationalStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + .SubscribeAttributeOperationalStatus(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } @@ -6810,15 +6800,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_TargetPositio .AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_TargetPositionLiftPercent100ths( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint16_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_TargetPositionLiftPercent100ths( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeTargetPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), - minInterval, maxInterval, change) + .SubscribeAttributeTargetPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), + minInterval, maxInterval) .AsInteger(); } @@ -6832,15 +6822,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_TargetPositio .AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_TargetPositionTiltPercent100ths( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint16_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_TargetPositionTiltPercent100ths( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeTargetPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), - minInterval, maxInterval, change) + .SubscribeAttributeTargetPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), + minInterval, maxInterval) .AsInteger(); } @@ -6865,15 +6855,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositi .AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercent100ths( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint16_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercent100ths( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), - minInterval, maxInterval, change) + .SubscribeAttributeCurrentPositionLiftPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), + minInterval, maxInterval) .AsInteger(); } @@ -6888,15 +6878,15 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_CurrentPositi .AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercent100ths( - chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval, uint16_t change) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercent100ths( + chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeCurrentPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), - minInterval, maxInterval, change) + .SubscribeAttributeCurrentPositionTiltPercent100ths(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), + minInterval, maxInterval) .AsInteger(); } @@ -6973,7 +6963,7 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_WindowCovering_SafetyStatus( return cluster.ReadAttributeSafetyStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger(); } -chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_SafetyStatus(chip::Controller::Device * device, +chip::ChipError::StorageType chip_ime_SubscribeAttribute_WindowCovering_SafetyStatus(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { @@ -6981,7 +6971,7 @@ chip::ChipError::StorageType chip_ime_ConfigureAttribute_WindowCovering_SafetySt chip::Controller::WindowCoveringCluster cluster; cluster.Associate(device, ZCLendpointId); return cluster - .ConfigureAttributeSafetyStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, + .SubscribeAttributeSafetyStatus(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval) .AsInteger(); } diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index e45e186d873955..388d546e002f6f 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -3914,12 +3914,12 @@ def ReadAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, e if res != 0: raise self._ChipStack.ErrorToException(res) - def ConfigureAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, endpoint: int, minInterval: int, maxInterval: int, change: int, imEnabled): - func = getattr(self, "Cluster{}_ConfigureAttribute{}".format(cluster, attribute), None) + def SubscribeAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, endpoint: int, minInterval: int, maxInterval: int, imEnabled): + func = getattr(self, "Cluster{}_SubscribeAttribute{}".format(cluster, attribute), None) if not func: raise UnknownAttribute(cluster, attribute) funcCaller = self._ChipStack.Call if imEnabled else self._ChipStack.CallAsync - funcCaller(lambda: func(device, endpoint, minInterval, maxInterval, change)) + funcCaller(lambda: func(device, endpoint, minInterval, maxInterval)) def WriteAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, endpoint: int, groupid: int, value, imEnabled): func = getattr(self, "Cluster{}_WriteAttribute{}".format(cluster, attribute), None) @@ -4672,14 +4672,14 @@ def ClusterBinaryInputBasic_WriteAttributeOutOfService(self, device: ctypes.c_vo return self._chipLib.chip_ime_WriteAttribute_BinaryInputBasic_OutOfService(device, ZCLendpoint, ZCLgroupid, value) def ClusterBinaryInputBasic_ReadAttributePresentValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_PresentValue(device, ZCLendpoint, ZCLgroupid) - def ClusterBinaryInputBasic_ConfigureAttributePresentValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_BinaryInputBasic_PresentValue(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterBinaryInputBasic_SubscribeAttributePresentValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_BinaryInputBasic_PresentValue(device, ZCLendpoint, minInterval, maxInterval) def ClusterBinaryInputBasic_WriteAttributePresentValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int, value: bool): return self._chipLib.chip_ime_WriteAttribute_BinaryInputBasic_PresentValue(device, ZCLendpoint, ZCLgroupid, value) def ClusterBinaryInputBasic_ReadAttributeStatusFlags(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_StatusFlags(device, ZCLendpoint, ZCLgroupid) - def ClusterBinaryInputBasic_ConfigureAttributeStatusFlags(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_BinaryInputBasic_StatusFlags(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterBinaryInputBasic_SubscribeAttributeStatusFlags(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_BinaryInputBasic_StatusFlags(device, ZCLendpoint, minInterval, maxInterval) def ClusterBinaryInputBasic_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterBinding_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -4719,30 +4719,30 @@ def ClusterBridgedDeviceBasic_ReadAttributeClusterRevision(self, device: ctypes. return self._chipLib.chip_ime_ReadAttribute_BridgedDeviceBasic_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterColorControl_ReadAttributeCurrentHue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentHue(device, ZCLendpoint, ZCLgroupid) - def ClusterColorControl_ConfigureAttributeCurrentHue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentHue(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterColorControl_SubscribeAttributeCurrentHue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentHue(device, ZCLendpoint, minInterval, maxInterval) def ClusterColorControl_ReadAttributeCurrentSaturation(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentSaturation(device, ZCLendpoint, ZCLgroupid) - def ClusterColorControl_ConfigureAttributeCurrentSaturation(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentSaturation(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterColorControl_SubscribeAttributeCurrentSaturation(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentSaturation(device, ZCLendpoint, minInterval, maxInterval) def ClusterColorControl_ReadAttributeRemainingTime(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_RemainingTime(device, ZCLendpoint, ZCLgroupid) def ClusterColorControl_ReadAttributeCurrentX(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentX(device, ZCLendpoint, ZCLgroupid) - def ClusterColorControl_ConfigureAttributeCurrentX(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentX(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterColorControl_SubscribeAttributeCurrentX(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentX(device, ZCLendpoint, minInterval, maxInterval) def ClusterColorControl_ReadAttributeCurrentY(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentY(device, ZCLendpoint, ZCLgroupid) - def ClusterColorControl_ConfigureAttributeCurrentY(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentY(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterColorControl_SubscribeAttributeCurrentY(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentY(device, ZCLendpoint, minInterval, maxInterval) def ClusterColorControl_ReadAttributeDriftCompensation(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_DriftCompensation(device, ZCLendpoint, ZCLgroupid) def ClusterColorControl_ReadAttributeCompensationText(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_CompensationText(device, ZCLendpoint, ZCLgroupid) def ClusterColorControl_ReadAttributeColorTemperature(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_ColorTemperature(device, ZCLendpoint, ZCLgroupid) - def ClusterColorControl_ConfigureAttributeColorTemperature(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_ColorControl_ColorTemperature(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterColorControl_SubscribeAttributeColorTemperature(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_ColorControl_ColorTemperature(device, ZCLendpoint, minInterval, maxInterval) def ClusterColorControl_ReadAttributeColorMode(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_ColorControl_ColorMode(device, ZCLendpoint, ZCLgroupid) def ClusterColorControl_ReadAttributeColorControlOptions(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -4877,8 +4877,8 @@ def ClusterDescriptor_ReadAttributeClusterRevision(self, device: ctypes.c_void_p return self._chipLib.chip_ime_ReadAttribute_Descriptor_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterDoorLock_ReadAttributeLockState(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_DoorLock_LockState(device, ZCLendpoint, ZCLgroupid) - def ClusterDoorLock_ConfigureAttributeLockState(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_DoorLock_LockState(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterDoorLock_SubscribeAttributeLockState(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_DoorLock_LockState(device, ZCLendpoint, minInterval, maxInterval) def ClusterDoorLock_ReadAttributeLockType(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_DoorLock_LockType(device, ZCLendpoint, ZCLgroupid) def ClusterDoorLock_ReadAttributeActuatorEnabled(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -4973,8 +4973,8 @@ def ClusterKeypadInput_ReadAttributeClusterRevision(self, device: ctypes.c_void_ return self._chipLib.chip_ime_ReadAttribute_KeypadInput_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterLevelControl_ReadAttributeCurrentLevel(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_LevelControl_CurrentLevel(device, ZCLendpoint, ZCLgroupid) - def ClusterLevelControl_ConfigureAttributeCurrentLevel(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_LevelControl_CurrentLevel(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterLevelControl_SubscribeAttributeCurrentLevel(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_LevelControl_CurrentLevel(device, ZCLendpoint, minInterval, maxInterval) def ClusterLevelControl_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_LevelControl_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterLowPower_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5019,8 +5019,8 @@ def ClusterOtaSoftwareUpdateRequestor_ReadAttributeClusterRevision(self, device: return self._chipLib.chip_ime_ReadAttribute_OtaSoftwareUpdateRequestor_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterOccupancySensing_ReadAttributeOccupancy(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_OccupancySensing_Occupancy(device, ZCLendpoint, ZCLgroupid) - def ClusterOccupancySensing_ConfigureAttributeOccupancy(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_OccupancySensing_Occupancy(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterOccupancySensing_SubscribeAttributeOccupancy(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_OccupancySensing_Occupancy(device, ZCLendpoint, minInterval, maxInterval) def ClusterOccupancySensing_ReadAttributeOccupancySensorType(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_OccupancySensing_OccupancySensorType(device, ZCLendpoint, ZCLgroupid) def ClusterOccupancySensing_ReadAttributeOccupancySensorTypeBitmap(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5029,8 +5029,8 @@ def ClusterOccupancySensing_ReadAttributeClusterRevision(self, device: ctypes.c_ return self._chipLib.chip_ime_ReadAttribute_OccupancySensing_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterOnOff_ReadAttributeOnOff(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_OnOff_OnOff(device, ZCLendpoint, ZCLgroupid) - def ClusterOnOff_ConfigureAttributeOnOff(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_OnOff_OnOff(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterOnOff_SubscribeAttributeOnOff(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_OnOff_OnOff(device, ZCLendpoint, minInterval, maxInterval) def ClusterOnOff_ReadAttributeGlobalSceneControl(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_OnOff_GlobalSceneControl(device, ZCLendpoint, ZCLgroupid) def ClusterOnOff_ReadAttributeOnTime(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5089,8 +5089,8 @@ def ClusterPowerSource_ReadAttributeClusterRevision(self, device: ctypes.c_void_ return self._chipLib.chip_ime_ReadAttribute_PowerSource_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterPressureMeasurement_ReadAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_PressureMeasurement_MeasuredValue(device, ZCLendpoint, ZCLgroupid) - def ClusterPressureMeasurement_ConfigureAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_PressureMeasurement_MeasuredValue(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterPressureMeasurement_SubscribeAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_PressureMeasurement_MeasuredValue(device, ZCLendpoint, minInterval, maxInterval) def ClusterPressureMeasurement_ReadAttributeMinMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_PressureMeasurement_MinMeasuredValue(device, ZCLendpoint, ZCLgroupid) def ClusterPressureMeasurement_ReadAttributeMaxMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5109,8 +5109,8 @@ def ClusterPumpConfigurationAndControl_ReadAttributeEffectiveControlMode(self, d return self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_EffectiveControlMode(device, ZCLendpoint, ZCLgroupid) def ClusterPumpConfigurationAndControl_ReadAttributeCapacity(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_Capacity(device, ZCLendpoint, ZCLgroupid) - def ClusterPumpConfigurationAndControl_ConfigureAttributeCapacity(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_PumpConfigurationAndControl_Capacity(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterPumpConfigurationAndControl_SubscribeAttributeCapacity(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_PumpConfigurationAndControl_Capacity(device, ZCLendpoint, minInterval, maxInterval) def ClusterPumpConfigurationAndControl_ReadAttributeOperationMode(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_OperationMode(device, ZCLendpoint, ZCLgroupid) def ClusterPumpConfigurationAndControl_WriteAttributeOperationMode(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int, value: int): @@ -5119,8 +5119,8 @@ def ClusterPumpConfigurationAndControl_ReadAttributeClusterRevision(self, device return self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterRelativeHumidityMeasurement_ReadAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_RelativeHumidityMeasurement_MeasuredValue(device, ZCLendpoint, ZCLgroupid) - def ClusterRelativeHumidityMeasurement_ConfigureAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_RelativeHumidityMeasurement_MeasuredValue(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterRelativeHumidityMeasurement_SubscribeAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_RelativeHumidityMeasurement_MeasuredValue(device, ZCLendpoint, minInterval, maxInterval) def ClusterRelativeHumidityMeasurement_ReadAttributeMinMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_RelativeHumidityMeasurement_MinMeasuredValue(device, ZCLendpoint, ZCLgroupid) def ClusterRelativeHumidityMeasurement_ReadAttributeMaxMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5151,8 +5151,8 @@ def ClusterSwitch_ReadAttributeNumberOfPositions(self, device: ctypes.c_void_p, return self._chipLib.chip_ime_ReadAttribute_Switch_NumberOfPositions(device, ZCLendpoint, ZCLgroupid) def ClusterSwitch_ReadAttributeCurrentPosition(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_Switch_CurrentPosition(device, ZCLendpoint, ZCLgroupid) - def ClusterSwitch_ConfigureAttributeCurrentPosition(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_Switch_CurrentPosition(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterSwitch_SubscribeAttributeCurrentPosition(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_Switch_CurrentPosition(device, ZCLendpoint, minInterval, maxInterval) def ClusterSwitch_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_Switch_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterTvChannel_ReadAttributeTvChannelList(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5169,8 +5169,8 @@ def ClusterTargetNavigator_ReadAttributeClusterRevision(self, device: ctypes.c_v return self._chipLib.chip_ime_ReadAttribute_TargetNavigator_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterTemperatureMeasurement_ReadAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_TemperatureMeasurement_MeasuredValue(device, ZCLendpoint, ZCLgroupid) - def ClusterTemperatureMeasurement_ConfigureAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_TemperatureMeasurement_MeasuredValue(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterTemperatureMeasurement_SubscribeAttributeMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_TemperatureMeasurement_MeasuredValue(device, ZCLendpoint, minInterval, maxInterval) def ClusterTemperatureMeasurement_ReadAttributeMinMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_TemperatureMeasurement_MinMeasuredValue(device, ZCLendpoint, ZCLgroupid) def ClusterTemperatureMeasurement_ReadAttributeMaxMeasuredValue(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5277,8 +5277,8 @@ def ClusterTestCluster_ReadAttributeClusterRevision(self, device: ctypes.c_void_ return self._chipLib.chip_ime_ReadAttribute_TestCluster_ClusterRevision(device, ZCLendpoint, ZCLgroupid) def ClusterThermostat_ReadAttributeLocalTemperature(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_Thermostat_LocalTemperature(device, ZCLendpoint, ZCLgroupid) - def ClusterThermostat_ConfigureAttributeLocalTemperature(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_Thermostat_LocalTemperature(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterThermostat_SubscribeAttributeLocalTemperature(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_Thermostat_LocalTemperature(device, ZCLendpoint, minInterval, maxInterval) def ClusterThermostat_ReadAttributeAbsMinHeatSetpointLimit(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_Thermostat_AbsMinHeatSetpointLimit(device, ZCLendpoint, ZCLgroupid) def ClusterThermostat_ReadAttributeAbsMaxHeatSetpointLimit(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5497,34 +5497,34 @@ def ClusterWindowCovering_ReadAttributeConfigStatus(self, device: ctypes.c_void_ return self._chipLib.chip_ime_ReadAttribute_WindowCovering_ConfigStatus(device, ZCLendpoint, ZCLgroupid) def ClusterWindowCovering_ReadAttributeCurrentPositionLiftPercentage(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercentage(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeCurrentPositionLiftPercentage(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercentage(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeCurrentPositionLiftPercentage(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercentage(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeCurrentPositionTiltPercentage(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercentage(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeCurrentPositionTiltPercentage(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercentage(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeCurrentPositionTiltPercentage(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercentage(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeOperationalStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_OperationalStatus(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeOperationalStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_OperationalStatus(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeOperationalStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_OperationalStatus(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeTargetPositionLiftPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_TargetPositionLiftPercent100ths(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeTargetPositionLiftPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_TargetPositionLiftPercent100ths(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeTargetPositionLiftPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_TargetPositionLiftPercent100ths(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeTargetPositionTiltPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_TargetPositionTiltPercent100ths(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeTargetPositionTiltPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_TargetPositionTiltPercent100ths(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeTargetPositionTiltPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_TargetPositionTiltPercent100ths(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeEndProductType(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_EndProductType(device, ZCLendpoint, ZCLgroupid) def ClusterWindowCovering_ReadAttributeCurrentPositionLiftPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercent100ths(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeCurrentPositionLiftPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercent100ths(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeCurrentPositionLiftPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercent100ths(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeCurrentPositionTiltPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercent100ths(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeCurrentPositionTiltPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercent100ths(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeCurrentPositionTiltPercent100ths(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercent100ths(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeInstalledOpenLimitLift(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_InstalledOpenLimitLift(device, ZCLendpoint, ZCLgroupid) def ClusterWindowCovering_ReadAttributeInstalledClosedLimitLift(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): @@ -5539,8 +5539,8 @@ def ClusterWindowCovering_WriteAttributeMode(self, device: ctypes.c_void_p, ZCLe return self._chipLib.chip_ime_WriteAttribute_WindowCovering_Mode(device, ZCLendpoint, ZCLgroupid, value) def ClusterWindowCovering_ReadAttributeSafetyStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_SafetyStatus(device, ZCLendpoint, ZCLgroupid) - def ClusterWindowCovering_ConfigureAttributeSafetyStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_SafetyStatus(device, ZCLendpoint, minInterval, maxInterval, change) + def ClusterWindowCovering_SubscribeAttributeSafetyStatus(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_SafetyStatus(device, ZCLendpoint, minInterval, maxInterval) def ClusterWindowCovering_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_WindowCovering_ClusterRevision(device, ZCLendpoint, ZCLgroupid) @@ -5738,18 +5738,18 @@ def InitLib(self, chipLib): # Cluster BinaryInputBasic ReadAttribute PresentValue self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_PresentValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_PresentValue.restype = ctypes.c_uint32 - # Cluster BinaryInputBasic ConfigureAttribute PresentValue - self._chipLib.chip_ime_ConfigureAttribute_BinaryInputBasic_PresentValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_BinaryInputBasic_PresentValue.restype = ctypes.c_uint32 + # Cluster BinaryInputBasic SubscribeAttribute PresentValue + self._chipLib.chip_ime_SubscribeAttribute_BinaryInputBasic_PresentValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_BinaryInputBasic_PresentValue.restype = ctypes.c_uint32 # Cluster BinaryInputBasic WriteAttribute PresentValue self._chipLib.chip_ime_WriteAttribute_BinaryInputBasic_PresentValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_bool] self._chipLib.chip_ime_WriteAttribute_BinaryInputBasic_PresentValue.restype = ctypes.c_uint32 # Cluster BinaryInputBasic ReadAttribute StatusFlags self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_StatusFlags.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_StatusFlags.restype = ctypes.c_uint32 - # Cluster BinaryInputBasic ConfigureAttribute StatusFlags - self._chipLib.chip_ime_ConfigureAttribute_BinaryInputBasic_StatusFlags.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_BinaryInputBasic_StatusFlags.restype = ctypes.c_uint32 + # Cluster BinaryInputBasic SubscribeAttribute StatusFlags + self._chipLib.chip_ime_SubscribeAttribute_BinaryInputBasic_StatusFlags.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_BinaryInputBasic_StatusFlags.restype = ctypes.c_uint32 # Cluster BinaryInputBasic ReadAttribute ClusterRevision self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_BinaryInputBasic_ClusterRevision.restype = ctypes.c_uint32 @@ -5873,30 +5873,30 @@ def InitLib(self, chipLib): # Cluster ColorControl ReadAttribute CurrentHue self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentHue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentHue.restype = ctypes.c_uint32 - # Cluster ColorControl ConfigureAttribute CurrentHue - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentHue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8] - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentHue.restype = ctypes.c_uint32 + # Cluster ColorControl SubscribeAttribute CurrentHue + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentHue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentHue.restype = ctypes.c_uint32 # Cluster ColorControl ReadAttribute CurrentSaturation self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentSaturation.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentSaturation.restype = ctypes.c_uint32 - # Cluster ColorControl ConfigureAttribute CurrentSaturation - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentSaturation.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8] - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentSaturation.restype = ctypes.c_uint32 + # Cluster ColorControl SubscribeAttribute CurrentSaturation + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentSaturation.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentSaturation.restype = ctypes.c_uint32 # Cluster ColorControl ReadAttribute RemainingTime self._chipLib.chip_ime_ReadAttribute_ColorControl_RemainingTime.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_RemainingTime.restype = ctypes.c_uint32 # Cluster ColorControl ReadAttribute CurrentX self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentX.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentX.restype = ctypes.c_uint32 - # Cluster ColorControl ConfigureAttribute CurrentX - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentX.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentX.restype = ctypes.c_uint32 + # Cluster ColorControl SubscribeAttribute CurrentX + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentX.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentX.restype = ctypes.c_uint32 # Cluster ColorControl ReadAttribute CurrentY self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentY.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_CurrentY.restype = ctypes.c_uint32 - # Cluster ColorControl ConfigureAttribute CurrentY - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentY.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_CurrentY.restype = ctypes.c_uint32 + # Cluster ColorControl SubscribeAttribute CurrentY + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentY.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_CurrentY.restype = ctypes.c_uint32 # Cluster ColorControl ReadAttribute DriftCompensation self._chipLib.chip_ime_ReadAttribute_ColorControl_DriftCompensation.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_DriftCompensation.restype = ctypes.c_uint32 @@ -5906,9 +5906,9 @@ def InitLib(self, chipLib): # Cluster ColorControl ReadAttribute ColorTemperature self._chipLib.chip_ime_ReadAttribute_ColorControl_ColorTemperature.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_ColorTemperature.restype = ctypes.c_uint32 - # Cluster ColorControl ConfigureAttribute ColorTemperature - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_ColorTemperature.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_ColorControl_ColorTemperature.restype = ctypes.c_uint32 + # Cluster ColorControl SubscribeAttribute ColorTemperature + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_ColorTemperature.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_ColorControl_ColorTemperature.restype = ctypes.c_uint32 # Cluster ColorControl ReadAttribute ColorMode self._chipLib.chip_ime_ReadAttribute_ColorControl_ColorMode.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_ColorControl_ColorMode.restype = ctypes.c_uint32 @@ -6192,9 +6192,9 @@ def InitLib(self, chipLib): # Cluster DoorLock ReadAttribute LockState self._chipLib.chip_ime_ReadAttribute_DoorLock_LockState.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_DoorLock_LockState.restype = ctypes.c_uint32 - # Cluster DoorLock ConfigureAttribute LockState - self._chipLib.chip_ime_ConfigureAttribute_DoorLock_LockState.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_DoorLock_LockState.restype = ctypes.c_uint32 + # Cluster DoorLock SubscribeAttribute LockState + self._chipLib.chip_ime_SubscribeAttribute_DoorLock_LockState.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_DoorLock_LockState.restype = ctypes.c_uint32 # Cluster DoorLock ReadAttribute LockType self._chipLib.chip_ime_ReadAttribute_DoorLock_LockType.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_DoorLock_LockType.restype = ctypes.c_uint32 @@ -6410,9 +6410,9 @@ def InitLib(self, chipLib): # Cluster LevelControl ReadAttribute CurrentLevel self._chipLib.chip_ime_ReadAttribute_LevelControl_CurrentLevel.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_LevelControl_CurrentLevel.restype = ctypes.c_uint32 - # Cluster LevelControl ConfigureAttribute CurrentLevel - self._chipLib.chip_ime_ConfigureAttribute_LevelControl_CurrentLevel.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8] - self._chipLib.chip_ime_ConfigureAttribute_LevelControl_CurrentLevel.restype = ctypes.c_uint32 + # Cluster LevelControl SubscribeAttribute CurrentLevel + self._chipLib.chip_ime_SubscribeAttribute_LevelControl_CurrentLevel.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_LevelControl_CurrentLevel.restype = ctypes.c_uint32 # Cluster LevelControl ReadAttribute ClusterRevision self._chipLib.chip_ime_ReadAttribute_LevelControl_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_LevelControl_ClusterRevision.restype = ctypes.c_uint32 @@ -6573,9 +6573,9 @@ def InitLib(self, chipLib): # Cluster OccupancySensing ReadAttribute Occupancy self._chipLib.chip_ime_ReadAttribute_OccupancySensing_Occupancy.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_OccupancySensing_Occupancy.restype = ctypes.c_uint32 - # Cluster OccupancySensing ConfigureAttribute Occupancy - self._chipLib.chip_ime_ConfigureAttribute_OccupancySensing_Occupancy.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_OccupancySensing_Occupancy.restype = ctypes.c_uint32 + # Cluster OccupancySensing SubscribeAttribute Occupancy + self._chipLib.chip_ime_SubscribeAttribute_OccupancySensing_Occupancy.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_OccupancySensing_Occupancy.restype = ctypes.c_uint32 # Cluster OccupancySensing ReadAttribute OccupancySensorType self._chipLib.chip_ime_ReadAttribute_OccupancySensing_OccupancySensorType.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_OccupancySensing_OccupancySensorType.restype = ctypes.c_uint32 @@ -6607,9 +6607,9 @@ def InitLib(self, chipLib): # Cluster OnOff ReadAttribute OnOff self._chipLib.chip_ime_ReadAttribute_OnOff_OnOff.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_OnOff_OnOff.restype = ctypes.c_uint32 - # Cluster OnOff ConfigureAttribute OnOff - self._chipLib.chip_ime_ConfigureAttribute_OnOff_OnOff.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_OnOff_OnOff.restype = ctypes.c_uint32 + # Cluster OnOff SubscribeAttribute OnOff + self._chipLib.chip_ime_SubscribeAttribute_OnOff_OnOff.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_OnOff_OnOff.restype = ctypes.c_uint32 # Cluster OnOff ReadAttribute GlobalSceneControl self._chipLib.chip_ime_ReadAttribute_OnOff_GlobalSceneControl.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_OnOff_GlobalSceneControl.restype = ctypes.c_uint32 @@ -6728,9 +6728,9 @@ def InitLib(self, chipLib): # Cluster PressureMeasurement ReadAttribute MeasuredValue self._chipLib.chip_ime_ReadAttribute_PressureMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_PressureMeasurement_MeasuredValue.restype = ctypes.c_uint32 - # Cluster PressureMeasurement ConfigureAttribute MeasuredValue - self._chipLib.chip_ime_ConfigureAttribute_PressureMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_int16] - self._chipLib.chip_ime_ConfigureAttribute_PressureMeasurement_MeasuredValue.restype = ctypes.c_uint32 + # Cluster PressureMeasurement SubscribeAttribute MeasuredValue + self._chipLib.chip_ime_SubscribeAttribute_PressureMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_PressureMeasurement_MeasuredValue.restype = ctypes.c_uint32 # Cluster PressureMeasurement ReadAttribute MinMeasuredValue self._chipLib.chip_ime_ReadAttribute_PressureMeasurement_MinMeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_PressureMeasurement_MinMeasuredValue.restype = ctypes.c_uint32 @@ -6759,9 +6759,9 @@ def InitLib(self, chipLib): # Cluster PumpConfigurationAndControl ReadAttribute Capacity self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_Capacity.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_Capacity.restype = ctypes.c_uint32 - # Cluster PumpConfigurationAndControl ConfigureAttribute Capacity - self._chipLib.chip_ime_ConfigureAttribute_PumpConfigurationAndControl_Capacity.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_int16] - self._chipLib.chip_ime_ConfigureAttribute_PumpConfigurationAndControl_Capacity.restype = ctypes.c_uint32 + # Cluster PumpConfigurationAndControl SubscribeAttribute Capacity + self._chipLib.chip_ime_SubscribeAttribute_PumpConfigurationAndControl_Capacity.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_PumpConfigurationAndControl_Capacity.restype = ctypes.c_uint32 # Cluster PumpConfigurationAndControl ReadAttribute OperationMode self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_OperationMode.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_PumpConfigurationAndControl_OperationMode.restype = ctypes.c_uint32 @@ -6775,9 +6775,9 @@ def InitLib(self, chipLib): # Cluster RelativeHumidityMeasurement ReadAttribute MeasuredValue self._chipLib.chip_ime_ReadAttribute_RelativeHumidityMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_RelativeHumidityMeasurement_MeasuredValue.restype = ctypes.c_uint32 - # Cluster RelativeHumidityMeasurement ConfigureAttribute MeasuredValue - self._chipLib.chip_ime_ConfigureAttribute_RelativeHumidityMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_RelativeHumidityMeasurement_MeasuredValue.restype = ctypes.c_uint32 + # Cluster RelativeHumidityMeasurement SubscribeAttribute MeasuredValue + self._chipLib.chip_ime_SubscribeAttribute_RelativeHumidityMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_RelativeHumidityMeasurement_MeasuredValue.restype = ctypes.c_uint32 # Cluster RelativeHumidityMeasurement ReadAttribute MinMeasuredValue self._chipLib.chip_ime_ReadAttribute_RelativeHumidityMeasurement_MinMeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_RelativeHumidityMeasurement_MinMeasuredValue.restype = ctypes.c_uint32 @@ -6850,9 +6850,9 @@ def InitLib(self, chipLib): # Cluster Switch ReadAttribute CurrentPosition self._chipLib.chip_ime_ReadAttribute_Switch_CurrentPosition.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_Switch_CurrentPosition.restype = ctypes.c_uint32 - # Cluster Switch ConfigureAttribute CurrentPosition - self._chipLib.chip_ime_ConfigureAttribute_Switch_CurrentPosition.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8] - self._chipLib.chip_ime_ConfigureAttribute_Switch_CurrentPosition.restype = ctypes.c_uint32 + # Cluster Switch SubscribeAttribute CurrentPosition + self._chipLib.chip_ime_SubscribeAttribute_Switch_CurrentPosition.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_Switch_CurrentPosition.restype = ctypes.c_uint32 # Cluster Switch ReadAttribute ClusterRevision self._chipLib.chip_ime_ReadAttribute_Switch_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_Switch_ClusterRevision.restype = ctypes.c_uint32 @@ -6892,9 +6892,9 @@ def InitLib(self, chipLib): # Cluster TemperatureMeasurement ReadAttribute MeasuredValue self._chipLib.chip_ime_ReadAttribute_TemperatureMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_TemperatureMeasurement_MeasuredValue.restype = ctypes.c_uint32 - # Cluster TemperatureMeasurement ConfigureAttribute MeasuredValue - self._chipLib.chip_ime_ConfigureAttribute_TemperatureMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_int16] - self._chipLib.chip_ime_ConfigureAttribute_TemperatureMeasurement_MeasuredValue.restype = ctypes.c_uint32 + # Cluster TemperatureMeasurement SubscribeAttribute MeasuredValue + self._chipLib.chip_ime_SubscribeAttribute_TemperatureMeasurement_MeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_TemperatureMeasurement_MeasuredValue.restype = ctypes.c_uint32 # Cluster TemperatureMeasurement ReadAttribute MinMeasuredValue self._chipLib.chip_ime_ReadAttribute_TemperatureMeasurement_MinMeasuredValue.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_TemperatureMeasurement_MinMeasuredValue.restype = ctypes.c_uint32 @@ -7083,9 +7083,9 @@ def InitLib(self, chipLib): # Cluster Thermostat ReadAttribute LocalTemperature self._chipLib.chip_ime_ReadAttribute_Thermostat_LocalTemperature.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_Thermostat_LocalTemperature.restype = ctypes.c_uint32 - # Cluster Thermostat ConfigureAttribute LocalTemperature - self._chipLib.chip_ime_ConfigureAttribute_Thermostat_LocalTemperature.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_int16] - self._chipLib.chip_ime_ConfigureAttribute_Thermostat_LocalTemperature.restype = ctypes.c_uint32 + # Cluster Thermostat SubscribeAttribute LocalTemperature + self._chipLib.chip_ime_SubscribeAttribute_Thermostat_LocalTemperature.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_Thermostat_LocalTemperature.restype = ctypes.c_uint32 # Cluster Thermostat ReadAttribute AbsMinHeatSetpointLimit self._chipLib.chip_ime_ReadAttribute_Thermostat_AbsMinHeatSetpointLimit.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_Thermostat_AbsMinHeatSetpointLimit.restype = ctypes.c_uint32 @@ -7445,48 +7445,48 @@ def InitLib(self, chipLib): # Cluster WindowCovering ReadAttribute CurrentPositionLiftPercentage self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercentage.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercentage.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute CurrentPositionLiftPercentage - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercentage.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercentage.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute CurrentPositionLiftPercentage + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercentage.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercentage.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute CurrentPositionTiltPercentage self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercentage.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercentage.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute CurrentPositionTiltPercentage - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercentage.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercentage.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute CurrentPositionTiltPercentage + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercentage.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercentage.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute OperationalStatus self._chipLib.chip_ime_ReadAttribute_WindowCovering_OperationalStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_OperationalStatus.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute OperationalStatus - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_OperationalStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_OperationalStatus.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute OperationalStatus + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_OperationalStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_OperationalStatus.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute TargetPositionLiftPercent100ths self._chipLib.chip_ime_ReadAttribute_WindowCovering_TargetPositionLiftPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_TargetPositionLiftPercent100ths.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute TargetPositionLiftPercent100ths - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_TargetPositionLiftPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_TargetPositionLiftPercent100ths.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute TargetPositionLiftPercent100ths + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_TargetPositionLiftPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_TargetPositionLiftPercent100ths.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute TargetPositionTiltPercent100ths self._chipLib.chip_ime_ReadAttribute_WindowCovering_TargetPositionTiltPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_TargetPositionTiltPercent100ths.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute TargetPositionTiltPercent100ths - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_TargetPositionTiltPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_TargetPositionTiltPercent100ths.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute TargetPositionTiltPercent100ths + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_TargetPositionTiltPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_TargetPositionTiltPercent100ths.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute EndProductType self._chipLib.chip_ime_ReadAttribute_WindowCovering_EndProductType.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_EndProductType.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute CurrentPositionLiftPercent100ths self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionLiftPercent100ths.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute CurrentPositionLiftPercent100ths - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionLiftPercent100ths.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute CurrentPositionLiftPercent100ths + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionLiftPercent100ths.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute CurrentPositionTiltPercent100ths self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_CurrentPositionTiltPercent100ths.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute CurrentPositionTiltPercent100ths - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_CurrentPositionTiltPercent100ths.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute CurrentPositionTiltPercent100ths + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercent100ths.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_CurrentPositionTiltPercent100ths.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute InstalledOpenLimitLift self._chipLib.chip_ime_ReadAttribute_WindowCovering_InstalledOpenLimitLift.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_InstalledOpenLimitLift.restype = ctypes.c_uint32 @@ -7508,9 +7508,9 @@ def InitLib(self, chipLib): # Cluster WindowCovering ReadAttribute SafetyStatus self._chipLib.chip_ime_ReadAttribute_WindowCovering_SafetyStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_SafetyStatus.restype = ctypes.c_uint32 - # Cluster WindowCovering ConfigureAttribute SafetyStatus - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_SafetyStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] - self._chipLib.chip_ime_ConfigureAttribute_WindowCovering_SafetyStatus.restype = ctypes.c_uint32 + # Cluster WindowCovering SubscribeAttribute SafetyStatus + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_SafetyStatus.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_WindowCovering_SafetyStatus.restype = ctypes.c_uint32 # Cluster WindowCovering ReadAttribute ClusterRevision self._chipLib.chip_ime_ReadAttribute_WindowCovering_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_WindowCovering_ClusterRevision.restype = ctypes.c_uint32 diff --git a/src/controller/python/templates/python-CHIPClusters-cpp.zapt b/src/controller/python/templates/python-CHIPClusters-cpp.zapt index c631e89cc9d0b3..a145654475d436 100644 --- a/src/controller/python/templates/python-CHIPClusters-cpp.zapt +++ b/src/controller/python/templates/python-CHIPClusters-cpp.zapt @@ -137,16 +137,16 @@ chip::ChipError::StorageType chip_ime_ReadAttribute_{{asUpperCamelCase parent.na } {{#if isReportableAttribute}} -chip::ChipError::StorageType chip_ime_ConfigureAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval{{#if isAnalog}}, {{chipType}} change{{/if}}) +chip::ChipError::StorageType chip_ime_SubscribeAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}(chip::Controller::Device * device, chip::EndpointId ZCLendpointId, uint16_t minInterval, uint16_t maxInterval) { VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); chip::Controller::{{asUpperCamelCase parent.name}}Cluster cluster; cluster.Associate(device, ZCLendpointId); {{#if isList}} chip::Callback::Callback<{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}ListAttributeCallback> * onSuccessCallback = new chip::Callback::Callback<{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}ListAttributeCallback>(On{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}ListAttributeResponse, nullptr); - return cluster.ConfigureAttribute{{asUpperCamelCase name}}(onSuccessCallback->Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval{{#if isAnalog}}, change{{/if}}).AsInteger(); + return cluster.SubscribeAttribute{{asUpperCamelCase name}}(onSuccessCallback->Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval).AsInteger(); {{else}} - return cluster.ConfigureAttribute{{asUpperCamelCase name}}(g{{chipCallback.name}}AttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval{{#if isAnalog}}, change{{/if}}).AsInteger(); + return cluster.SubscribeAttribute{{asUpperCamelCase name}}(g{{chipCallback.name}}AttributeCallback.Cancel(), gDefaultFailureCallback.Cancel(), minInterval, maxInterval).AsInteger(); {{/if}} } {{/if}} diff --git a/src/controller/python/templates/python-CHIPClusters-py.zapt b/src/controller/python/templates/python-CHIPClusters-py.zapt index f0620b544ba6ce..77661484222cd9 100644 --- a/src/controller/python/templates/python-CHIPClusters-py.zapt +++ b/src/controller/python/templates/python-CHIPClusters-py.zapt @@ -99,12 +99,12 @@ class ChipClusters: if res != 0: raise self._ChipStack.ErrorToException(res) - def ConfigureAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, endpoint: int, minInterval: int, maxInterval: int, change: int, imEnabled): - func = getattr(self, "Cluster{}_ConfigureAttribute{}".format(cluster, attribute), None) + def SubscribeAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, endpoint: int, minInterval: int, maxInterval: int, imEnabled): + func = getattr(self, "Cluster{}_SubscribeAttribute{}".format(cluster, attribute), None) if not func: raise UnknownAttribute(cluster, attribute) funcCaller = self._ChipStack.Call if imEnabled else self._ChipStack.CallAsync - funcCaller(lambda: func(device, endpoint, minInterval, maxInterval, change)) + funcCaller(lambda: func(device, endpoint, minInterval, maxInterval)) def WriteAttribute(self, device: ctypes.c_void_p, cluster: str, attribute: str, endpoint: int, groupid: int, value, imEnabled): func = getattr(self, "Cluster{}_WriteAttribute{}".format(cluster, attribute), None) @@ -136,8 +136,8 @@ class ChipClusters: def Cluster{{asUpperCamelCase parent.name}}_ReadAttribute{{asUpperCamelCase name}}(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int): return self._chipLib.chip_ime_ReadAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}(device, ZCLendpoint, ZCLgroupid) {{#if isReportableAttribute}} - def Cluster{{asUpperCamelCase parent.name}}_ConfigureAttribute{{asUpperCamelCase name}}(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int, change: int): - return self._chipLib.chip_ime_ConfigureAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}(device, ZCLendpoint, minInterval, maxInterval, change) + def Cluster{{asUpperCamelCase parent.name}}_SubscribeAttribute{{asUpperCamelCase name}}(self, device: ctypes.c_void_p, ZCLendpoint: int, minInterval: int, maxInterval: int): + return self._chipLib.chip_ime_SubscribeAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}(device, ZCLendpoint, minInterval, maxInterval) {{/if}} {{#if isWritableAttribute}} def Cluster{{asUpperCamelCase parent.name}}_WriteAttribute{{asUpperCamelCase name}}(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int, value: {{ asPythonType chipType }}): @@ -170,9 +170,9 @@ class ChipClusters: self._chipLib.chip_ime_ReadAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16] self._chipLib.chip_ime_ReadAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}.restype = ctypes.c_uint32 {{#if isReportableAttribute}} - # Cluster {{asUpperCamelCase parent.name}} ConfigureAttribute {{asUpperCamelCase name}} - self._chipLib.chip_ime_ConfigureAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16{{#if isAnalog}}, ctypes.{{asPythonCType chipType}}{{/if}}] - self._chipLib.chip_ime_ConfigureAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}.restype = ctypes.c_uint32 + # Cluster {{asUpperCamelCase parent.name}} SubscribeAttribute {{asUpperCamelCase name}} + self._chipLib.chip_ime_SubscribeAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16, ctypes.c_uint16] + self._chipLib.chip_ime_SubscribeAttribute_{{asUpperCamelCase parent.name}}_{{asUpperCamelCase name}}.restype = ctypes.c_uint32 {{/if}} {{#if isWritableAttribute}} # Cluster {{asUpperCamelCase parent.name}} WriteAttribute {{asUpperCamelCase name}} diff --git a/src/controller/python/test/test_scripts/base.py b/src/controller/python/test/test_scripts/base.py index 992010038eac62..8d2e54cd2a12c4 100644 --- a/src/controller/python/test/test_scripts/base.py +++ b/src/controller/python/test/test_scripts/base.py @@ -340,8 +340,8 @@ def run(self): # OnOff Cluster, OnOff Attribute handler = _subscriptionHandler(subscribedPath, self.logger) IM.SetAttributeReportCallback(subscribedPath, handler) - self.devCtrl.ZCLConfigureAttribute( - "OnOff", "OnOff", nodeid, endpoint, 1, 10, 0) + self.devCtrl.ZCLSubscribeAttribute( + "OnOff", "OnOff", nodeid, endpoint, 1, 10) changeThread = _conductAttributeChange( self.devCtrl, nodeid, endpoint) changeThread.start() diff --git a/src/darwin/CHIPTool/CHIPTool/View Controllers/Temperature Sensor/TemperatureSensorViewController.m b/src/darwin/CHIPTool/CHIPTool/View Controllers/Temperature Sensor/TemperatureSensorViewController.m index b81ada3eb01bb0..dd82722484607c 100644 --- a/src/darwin/CHIPTool/CHIPTool/View Controllers/Temperature Sensor/TemperatureSensorViewController.m +++ b/src/darwin/CHIPTool/CHIPTool/View Controllers/Temperature Sensor/TemperatureSensorViewController.m @@ -205,7 +205,7 @@ - (void)reportFromUserEnteredSettings [[CHIPTemperatureMeasurement alloc] initWithDevice:chipDevice endpoint:1 queue:dispatch_get_main_queue()]; [cluster - configureAttributeMeasuredValueWithMinInterval:minIntervalSeconds + subscribeAttributeMeasuredValueWithMinInterval:minIntervalSeconds maxInterval:maxIntervalSeconds change:deltaInCelsius responseHandler:^(NSError * error, NSDictionary * values) { diff --git a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt index 0a6c97a5eb1176..ebeb74a0592831 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc-src.zapt @@ -59,10 +59,10 @@ using chip::Callback::Cancelable; {{#if isReportableAttribute}} {{#*inline "callbackName"}}DefaultSuccess{{/inline}} {{#*inline "callbackParams"}}, minInterval, maxInterval{{#if isAnalog}}, change{{/if}}{{/inline}} -- (void) configure{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval{{#if isAnalog}} change:({{chipType}})change{{/if}} responseHandler:(ResponseHandler)responseHandler +- (void) subscribe{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIP{{>callbackName}}CallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.Configure{{>attribute}}(success, failure{{>callbackParams}}); + return self.cppCluster.Subscribe{{>attribute}}(success, failure{{>callbackParams}}); }); } diff --git a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt index e548e5db98af04..5cb175cdf56303 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPClustersObjc.zapt @@ -36,7 +36,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)write{{>attribute}}WithValue:({{asObjectiveCBasicType type}})value responseHandler:(ResponseHandler)responseHandler; {{/if}} {{#if isReportableAttribute}} -- (void) configure{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval{{#if isAnalog}} change:({{chipType}})change{{/if}} responseHandler:(ResponseHandler)responseHandler; +- (void) subscribe{{>attribute}}WithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void) report{{>attribute}}WithResponseHandler:(ResponseHandler)responseHandler; {{/if}} {{/chip_server_cluster_attributes}} diff --git a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt index 9df479373c4a2e..682d6fc0de748c 100644 --- a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt @@ -33,7 +33,7 @@ bool testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase {{#if isCommand}} [cluster {{asLowerCamelCase command}}:{{#chip_tests_item_parameters}}{{#not_first}}{{asLowerCamelCase name}}:{{/not_first}}{{asLowerCamelCase name}}Argument {{#last}}responseHandler:{{/last}}{{/chip_tests_item_parameters}}^(NSError * err, NSDictionary * values) { {{else if isSubscribeAttribute}} - [cluster configureAttribute{{asUpperCamelCase attribute}}WithMinInterval:minIntervalArgument + [cluster subscribeAttribute{{asUpperCamelCase attribute}}WithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument responseHandler:^(NSError * err, NSDictionary * values) { {{else if isWaitForReport}} diff --git a/src/darwin/Framework/CHIP/templates/partials/testsuite/WaitForAttributeReport.zapt b/src/darwin/Framework/CHIP/templates/partials/testsuite/WaitForAttributeReport.zapt deleted file mode 100644 index 33c9332063e08e..00000000000000 --- a/src/darwin/Framework/CHIP/templates/partials/testsuite/WaitForAttributeReport.zapt +++ /dev/null @@ -1,14 +0,0 @@ -{{#chip_tests_WaitForAttributeReport_attribute_info}} - CHIPDevice * device = GetPairedDevice(kDeviceId); - dispatch_queue_t queue = dispatch_get_main_queue(); - CHIP{{asUpperCamelCase cluster}} * cluster = [[CHIP{{asUpperCamelCase cluster}} alloc] initWithDevice:device endpoint:{{endpoint}} queue:queue]; - XCTAssertNotNil(cluster); - - [cluster reportAttribute{{asUpperCamelCase attribute}}WithResponseHandler:^(NSError * err, NSDictionary * values) { - NSLog(@"Reporting Test Report: %@", err); - XCTAssertEqual(err.code, 0); - - {{> process_response_value}} - [expectation fulfill]; - }]; -{{/chip_tests_WaitForAttributeReport_attribute_info}} diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h index df1cd2930ce873..6df56cc7e189ba 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h @@ -208,13 +208,13 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributePresentValueWithResponseHandler:(ResponseHandler)responseHandler; - (void)writeAttributePresentValueWithValue:(bool)value responseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributePresentValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributePresentValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributePresentValueWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeStatusFlagsWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeStatusFlagsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeStatusFlagsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeStatusFlagsWithResponseHandler:(ResponseHandler)responseHandler; @@ -399,32 +399,28 @@ NS_ASSUME_NONNULL_BEGIN - (void)stopMoveStep:(uint8_t)optionsMask optionsOverride:(uint8_t)optionsOverride responseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentHueWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentHueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentHueWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentSaturationWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentSaturationWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentSaturationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentSaturationWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeRemainingTimeWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentXWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentXWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentXWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentYWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentYWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentYWithResponseHandler:(ResponseHandler)responseHandler; @@ -433,9 +429,8 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeCompensationTextWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeColorTemperatureWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeColorTemperatureWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeColorTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeColorTemperatureWithResponseHandler:(ResponseHandler)responseHandler; @@ -646,7 +641,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)unlockWithTimeout:(uint16_t)timeoutInSeconds pin:(NSString *)pin responseHandler:(ResponseHandler)responseHandler; - (void)readAttributeLockStateWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeLockStateWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeLockStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeLockStateWithResponseHandler:(ResponseHandler)responseHandler; @@ -882,9 +877,8 @@ NS_ASSUME_NONNULL_BEGIN - (void)stopWithOnOff:(ResponseHandler)responseHandler; - (void)readAttributeCurrentLevelWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentLevelWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentLevelWithResponseHandler:(ResponseHandler)responseHandler; @@ -1062,7 +1056,7 @@ NS_ASSUME_NONNULL_BEGIN @interface CHIPOccupancySensing : CHIPCluster - (void)readAttributeOccupancyWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeOccupancyWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeOccupancyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeOccupancyWithResponseHandler:(ResponseHandler)responseHandler; @@ -1092,7 +1086,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)toggle:(ResponseHandler)responseHandler; - (void)readAttributeOnOffWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeOnOffWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeOnOffWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeOnOffWithResponseHandler:(ResponseHandler)responseHandler; @@ -1197,9 +1191,8 @@ NS_ASSUME_NONNULL_BEGIN @interface CHIPPressureMeasurement : CHIPCluster - (void)readAttributeMeasuredValueWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeMeasuredValueWithResponseHandler:(ResponseHandler)responseHandler; @@ -1228,9 +1221,8 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeEffectiveControlModeWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCapacityWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCapacityWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCapacityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCapacityWithResponseHandler:(ResponseHandler)responseHandler; @@ -1248,9 +1240,8 @@ NS_ASSUME_NONNULL_BEGIN @interface CHIPRelativeHumidityMeasurement : CHIPCluster - (void)readAttributeMeasuredValueWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeMeasuredValueWithResponseHandler:(ResponseHandler)responseHandler; @@ -1327,9 +1318,8 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeNumberOfPositionsWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentPositionWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentPositionWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentPositionWithResponseHandler:(ResponseHandler)responseHandler; @@ -1380,9 +1370,8 @@ NS_ASSUME_NONNULL_BEGIN @interface CHIPTemperatureMeasurement : CHIPCluster - (void)readAttributeMeasuredValueWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeMeasuredValueWithResponseHandler:(ResponseHandler)responseHandler; @@ -1499,9 +1488,8 @@ NS_ASSUME_NONNULL_BEGIN - (void)setpointRaiseLower:(uint8_t)mode amount:(int8_t)amount responseHandler:(ResponseHandler)responseHandler; - (void)readAttributeLocalTemperatureWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeLocalTemperatureWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeLocalTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeLocalTemperatureWithResponseHandler:(ResponseHandler)responseHandler; @@ -1767,52 +1755,46 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeConfigStatusWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentPositionLiftPercentageWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentPositionLiftPercentageWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionLiftPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentPositionLiftPercentageWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentPositionTiltPercentageWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentPositionTiltPercentageWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeOperationalStatusWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeOperationalStatusWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeTargetPositionLiftPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeTargetPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeTargetPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeTargetPositionLiftPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeTargetPositionTiltPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeTargetPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeTargetPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeTargetPositionTiltPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeEndProductTypeWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentPositionLiftPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentPositionLiftPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; - (void)readAttributeCurrentPositionTiltPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeCurrentPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeCurrentPositionTiltPercent100thsWithResponseHandler:(ResponseHandler)responseHandler; @@ -1828,7 +1810,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)writeAttributeModeWithValue:(uint8_t)value responseHandler:(ResponseHandler)responseHandler; - (void)readAttributeSafetyStatusWithResponseHandler:(ResponseHandler)responseHandler; -- (void)configureAttributeSafetyStatusWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeSafetyStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeSafetyStatusWithResponseHandler:(ResponseHandler)responseHandler; diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm index faa822e2432b8b..be5828d2ce69be 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm @@ -531,12 +531,12 @@ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributePresentValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributePresentValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributePresentValue(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributePresentValue(success, failure, minInterval, maxInterval); }); } @@ -557,12 +557,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeStatusFlagsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeStatusFlagsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeStatusFlags(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeStatusFlags(success, failure, minInterval, maxInterval); }); } @@ -987,13 +987,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeCurrentHueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentHueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentHue(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentHue(success, failure, minInterval, maxInterval); }); } @@ -1014,13 +1013,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeCurrentSaturationWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentSaturationWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentSaturation(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentSaturation(success, failure, minInterval, maxInterval); }); } @@ -1048,13 +1046,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeCurrentXWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentXWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentX(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentX(success, failure, minInterval, maxInterval); }); } @@ -1075,13 +1072,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeCurrentYWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentYWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentY(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentY(success, failure, minInterval, maxInterval); }); } @@ -1116,13 +1112,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeColorTemperatureWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeColorTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeColorTemperature(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeColorTemperature(success, failure, minInterval, maxInterval); }); } @@ -1883,12 +1878,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeLockStateWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeLockStateWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeLockState(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeLockState(success, failure, minInterval, maxInterval); }); } @@ -2515,13 +2510,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeCurrentLevelWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentLevelWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentLevel(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentLevel(success, failure, minInterval, maxInterval); }); } @@ -3022,12 +3016,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeOccupancyWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeOccupancyWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeOccupancy(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeOccupancy(success, failure, minInterval, maxInterval); }); } @@ -3123,12 +3117,12 @@ new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Ca }); } -- (void)configureAttributeOnOffWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeOnOffWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPBooleanAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeOnOff(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeOnOff(success, failure, minInterval, maxInterval); }); } @@ -3459,13 +3453,12 @@ new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeMeasuredValue(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); }); } @@ -3551,13 +3544,12 @@ new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeCapacityWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCapacityWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCapacity(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCapacity(success, failure, minInterval, maxInterval); }); } @@ -3608,13 +3600,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeMeasuredValue(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); }); } @@ -3833,13 +3824,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeCurrentPositionWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentPosition(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentPosition(success, failure, minInterval, maxInterval); }); } @@ -3970,13 +3960,12 @@ new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeMeasuredValueWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeMeasuredValue(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeMeasuredValue(success, failure, minInterval, maxInterval); }); } @@ -4452,13 +4441,12 @@ new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeLocalTemperatureWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeLocalTemperatureWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(int16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16sAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeLocalTemperature(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeLocalTemperature(success, failure, minInterval, maxInterval); }); } @@ -5352,13 +5340,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeCurrentPositionLiftPercentageWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionLiftPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentPositionLiftPercentage(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentPositionLiftPercentage(success, failure, minInterval, maxInterval); }); } @@ -5379,13 +5366,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionTiltPercentageWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint8_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentPositionTiltPercentage(success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentPositionTiltPercentage(success, failure, minInterval, maxInterval); }); } @@ -5406,12 +5392,12 @@ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Canc }); } -- (void)configureAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeOperationalStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeOperationalStatus(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeOperationalStatus(success, failure, minInterval, maxInterval); }); } @@ -5432,14 +5418,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeTargetPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeTargetPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeTargetPositionLiftPercent100ths( - success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeTargetPositionLiftPercent100ths(success, failure, minInterval, maxInterval); }); } @@ -5460,14 +5444,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeTargetPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeTargetPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeTargetPositionTiltPercent100ths( - success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeTargetPositionTiltPercent100ths(success, failure, minInterval, maxInterval); }); } @@ -5495,14 +5477,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeCurrentPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionLiftPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentPositionLiftPercent100ths( - success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentPositionLiftPercent100ths(success, failure, minInterval, maxInterval); }); } @@ -5523,14 +5503,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeCurrentPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeCurrentPositionTiltPercent100thsWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval - change:(uint16_t)change responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeCurrentPositionTiltPercent100ths( - success, failure, minInterval, maxInterval, change); + return self.cppCluster.SubscribeAttributeCurrentPositionTiltPercent100ths(success, failure, minInterval, maxInterval); }); } @@ -5593,12 +5571,12 @@ new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Can }); } -- (void)configureAttributeSafetyStatusWithMinInterval:(uint16_t)minInterval +- (void)subscribeAttributeSafetyStatusWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval responseHandler:(ResponseHandler)responseHandler { new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { - return self.cppCluster.ConfigureAttributeSafetyStatus(success, failure, minInterval, maxInterval); + return self.cppCluster.SubscribeAttributeSafetyStatus(success, failure, minInterval, maxInterval); }); } diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index b7901418fa692b..21a092c44a9bf9 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -2902,7 +2902,7 @@ - (void)testSendClusterTestSubscribe_OnOff_000002_SubscribeAttribute uint16_t minIntervalArgument = 2U; uint16_t maxIntervalArgument = 10U; - [cluster configureAttributeOnOffWithMinInterval:minIntervalArgument + [cluster subscribeAttributeOnOffWithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument responseHandler:^(NSError * err, NSDictionary * values) { NSLog(@"Subscribe OnOff Attribute Error: %@", err); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index a83a8afdd77666..0ddf9d8645d178 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -3469,7 +3469,7 @@ class ReportBinaryInputBasicPresentValue : public ModelCommand return err; } - return cluster.ConfigureAttributePresentValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributePresentValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } @@ -3549,7 +3549,7 @@ class ReportBinaryInputBasicStatusFlags : public ModelCommand return err; } - return cluster.ConfigureAttributeStatusFlags(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributeStatusFlags(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } @@ -5221,7 +5221,6 @@ class ReportColorControlCurrentHue : public ModelCommand AddArgument("attr-name", "current-hue"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT8_MAX, &mChange); ModelCommand::AddArguments(); } @@ -5245,8 +5244,8 @@ class ReportColorControlCurrentHue : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentHue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -5258,7 +5257,6 @@ class ReportColorControlCurrentHue : public ModelCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint8_t mChange; }; /* @@ -5303,7 +5301,6 @@ class ReportColorControlCurrentSaturation : public ModelCommand AddArgument("attr-name", "current-saturation"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT8_MAX, &mChange); ModelCommand::AddArguments(); } @@ -5327,8 +5324,8 @@ class ReportColorControlCurrentSaturation : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentSaturation(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -5340,7 +5337,6 @@ class ReportColorControlCurrentSaturation : public ModelCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint8_t mChange; }; /* @@ -5419,7 +5415,6 @@ class ReportColorControlCurrentX : public ModelCommand AddArgument("attr-name", "current-x"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -5443,8 +5438,8 @@ class ReportColorControlCurrentX : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentX(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -5456,7 +5451,6 @@ class ReportColorControlCurrentX : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -5501,7 +5495,6 @@ class ReportColorControlCurrentY : public ModelCommand AddArgument("attr-name", "current-y"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -5525,8 +5518,8 @@ class ReportColorControlCurrentY : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentY(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -5538,7 +5531,6 @@ class ReportColorControlCurrentY : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -5651,7 +5643,6 @@ class ReportColorControlColorTemperature : public ModelCommand AddArgument("attr-name", "color-temperature"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -5675,8 +5666,8 @@ class ReportColorControlColorTemperature : public ModelCommand return err; } - return cluster.ConfigureAttributeColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeColorTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -5688,7 +5679,6 @@ class ReportColorControlColorTemperature : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -9014,7 +9004,7 @@ class ReportDoorLockLockState : public ModelCommand return err; } - return cluster.ConfigureAttributeLockState(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributeLockState(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } @@ -11537,7 +11527,6 @@ class ReportLevelControlCurrentLevel : public ModelCommand AddArgument("attr-name", "current-level"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT8_MAX, &mChange); ModelCommand::AddArguments(); } @@ -11561,8 +11550,8 @@ class ReportLevelControlCurrentLevel : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentLevel(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentLevel(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -11574,7 +11563,6 @@ class ReportLevelControlCurrentLevel : public ModelCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint8_t mChange; }; /* @@ -13486,7 +13474,7 @@ class ReportOccupancySensingOccupancy : public ModelCommand return err; } - return cluster.ConfigureAttributeOccupancy(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributeOccupancy(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } @@ -13880,7 +13868,7 @@ class ReportOnOffOnOff : public ModelCommand return err; } - return cluster.ConfigureAttributeOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributeOnOff(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } @@ -15276,7 +15264,6 @@ class ReportPressureMeasurementMeasuredValue : public ModelCommand AddArgument("attr-name", "measured-value"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", INT16_MIN, INT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -15300,8 +15287,8 @@ class ReportPressureMeasurementMeasuredValue : public ModelCommand return err; } - return cluster.ConfigureAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -15313,7 +15300,6 @@ class ReportPressureMeasurementMeasuredValue : public ModelCommand new chip::Callback::Callback(OnInt16sAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - int16_t mChange; }; /* @@ -15646,7 +15632,6 @@ class ReportPumpConfigurationAndControlCapacity : public ModelCommand AddArgument("attr-name", "capacity"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", INT16_MIN, INT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -15670,8 +15655,8 @@ class ReportPumpConfigurationAndControlCapacity : public ModelCommand return err; } - return cluster.ConfigureAttributeCapacity(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCapacity(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -15683,7 +15668,6 @@ class ReportPumpConfigurationAndControlCapacity : public ModelCommand new chip::Callback::Callback(OnInt16sAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - int16_t mChange; }; /* @@ -15841,7 +15825,6 @@ class ReportRelativeHumidityMeasurementMeasuredValue : public ModelCommand AddArgument("attr-name", "measured-value"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -15865,8 +15848,8 @@ class ReportRelativeHumidityMeasurementMeasuredValue : public ModelCommand return err; } - return cluster.ConfigureAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -15878,7 +15861,6 @@ class ReportRelativeHumidityMeasurementMeasuredValue : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -16736,7 +16718,6 @@ class ReportSwitchCurrentPosition : public ModelCommand AddArgument("attr-name", "current-position"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT8_MAX, &mChange); ModelCommand::AddArguments(); } @@ -16760,8 +16741,8 @@ class ReportSwitchCurrentPosition : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentPosition(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentPosition(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -16773,7 +16754,6 @@ class ReportSwitchCurrentPosition : public ModelCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint8_t mChange; }; /* @@ -17239,7 +17219,6 @@ class ReportTemperatureMeasurementMeasuredValue : public ModelCommand AddArgument("attr-name", "measured-value"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", INT16_MIN, INT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -17263,8 +17242,8 @@ class ReportTemperatureMeasurementMeasuredValue : public ModelCommand return err; } - return cluster.ConfigureAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeMeasuredValue(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -17276,7 +17255,6 @@ class ReportTemperatureMeasurementMeasuredValue : public ModelCommand new chip::Callback::Callback(OnInt16sAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - int16_t mChange; }; /* @@ -19432,7 +19410,6 @@ class ReportThermostatLocalTemperature : public ModelCommand AddArgument("attr-name", "local-temperature"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", INT16_MIN, INT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -19456,8 +19433,8 @@ class ReportThermostatLocalTemperature : public ModelCommand return err; } - return cluster.ConfigureAttributeLocalTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, - mMaxInterval, mChange); + return cluster.SubscribeAttributeLocalTemperature(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); } private: @@ -19469,7 +19446,6 @@ class ReportThermostatLocalTemperature : public ModelCommand new chip::Callback::Callback(OnInt16sAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - int16_t mChange; }; /* @@ -23612,7 +23588,6 @@ class ReportWindowCoveringCurrentPositionLiftPercentage : public ModelCommand AddArgument("attr-name", "current-position-lift-percentage"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT8_MAX, &mChange); ModelCommand::AddArguments(); } @@ -23636,8 +23611,8 @@ class ReportWindowCoveringCurrentPositionLiftPercentage : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentPositionLiftPercentage(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), - mMinInterval, mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentPositionLiftPercentage(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mMinInterval, mMaxInterval); } private: @@ -23649,7 +23624,6 @@ class ReportWindowCoveringCurrentPositionLiftPercentage : public ModelCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint8_t mChange; }; /* @@ -23694,7 +23668,6 @@ class ReportWindowCoveringCurrentPositionTiltPercentage : public ModelCommand AddArgument("attr-name", "current-position-tilt-percentage"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT8_MAX, &mChange); ModelCommand::AddArguments(); } @@ -23718,8 +23691,8 @@ class ReportWindowCoveringCurrentPositionTiltPercentage : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentPositionTiltPercentage(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), - mMinInterval, mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentPositionTiltPercentage(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mMinInterval, mMaxInterval); } private: @@ -23731,7 +23704,6 @@ class ReportWindowCoveringCurrentPositionTiltPercentage : public ModelCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint8_t mChange; }; /* @@ -23799,7 +23771,7 @@ class ReportWindowCoveringOperationalStatus : public ModelCommand return err; } - return cluster.ConfigureAttributeOperationalStatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributeOperationalStatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } @@ -23856,7 +23828,6 @@ class ReportWindowCoveringTargetPositionLiftPercent100ths : public ModelCommand AddArgument("attr-name", "target-position-lift-percent100ths"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -23880,8 +23851,8 @@ class ReportWindowCoveringTargetPositionLiftPercent100ths : public ModelCommand return err; } - return cluster.ConfigureAttributeTargetPositionLiftPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), - mMinInterval, mMaxInterval, mChange); + return cluster.SubscribeAttributeTargetPositionLiftPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mMinInterval, mMaxInterval); } private: @@ -23893,7 +23864,6 @@ class ReportWindowCoveringTargetPositionLiftPercent100ths : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -23938,7 +23908,6 @@ class ReportWindowCoveringTargetPositionTiltPercent100ths : public ModelCommand AddArgument("attr-name", "target-position-tilt-percent100ths"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -23962,8 +23931,8 @@ class ReportWindowCoveringTargetPositionTiltPercent100ths : public ModelCommand return err; } - return cluster.ConfigureAttributeTargetPositionTiltPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), - mMinInterval, mMaxInterval, mChange); + return cluster.SubscribeAttributeTargetPositionTiltPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mMinInterval, mMaxInterval); } private: @@ -23975,7 +23944,6 @@ class ReportWindowCoveringTargetPositionTiltPercent100ths : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -24054,7 +24022,6 @@ class ReportWindowCoveringCurrentPositionLiftPercent100ths : public ModelCommand AddArgument("attr-name", "current-position-lift-percent100ths"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -24078,8 +24045,8 @@ class ReportWindowCoveringCurrentPositionLiftPercent100ths : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentPositionLiftPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), - mMinInterval, mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentPositionLiftPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mMinInterval, mMaxInterval); } private: @@ -24091,7 +24058,6 @@ class ReportWindowCoveringCurrentPositionLiftPercent100ths : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -24136,7 +24102,6 @@ class ReportWindowCoveringCurrentPositionTiltPercent100ths : public ModelCommand AddArgument("attr-name", "current-position-tilt-percent100ths"); AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); - AddArgument("change", 0, UINT16_MAX, &mChange); ModelCommand::AddArguments(); } @@ -24160,8 +24125,8 @@ class ReportWindowCoveringCurrentPositionTiltPercent100ths : public ModelCommand return err; } - return cluster.ConfigureAttributeCurrentPositionTiltPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), - mMinInterval, mMaxInterval, mChange); + return cluster.SubscribeAttributeCurrentPositionTiltPercent100ths(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), + mMinInterval, mMaxInterval); } private: @@ -24173,7 +24138,6 @@ class ReportWindowCoveringCurrentPositionTiltPercent100ths : public ModelCommand new chip::Callback::Callback(OnInt16uAttributeResponse, this); uint16_t mMinInterval; uint16_t mMaxInterval; - uint16_t mChange; }; /* @@ -24444,7 +24408,7 @@ class ReportWindowCoveringSafetyStatus : public ModelCommand return err; } - return cluster.ConfigureAttributeSafetyStatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, + return cluster.SubscribeAttributeSafetyStatus(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mMinInterval, mMaxInterval); } diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index ab66b0d3810459..3d6f877f44271b 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -6045,7 +6045,7 @@ class TestSubscribe_OnOff : public TestCommand uint16_t minIntervalArgument = 2U; uint16_t maxIntervalArgument = 10U; - return cluster.ConfigureAttributeOnOff(mOnSuccessCallback_2.Cancel(), mOnFailureCallback_2.Cancel(), minIntervalArgument, + return cluster.SubscribeAttributeOnOff(mOnSuccessCallback_2.Cancel(), mOnFailureCallback_2.Cancel(), minIntervalArgument, maxIntervalArgument); } diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp index 446fcad66af41c..970de8382c9c36 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp @@ -1164,11 +1164,10 @@ CHIP_ERROR BinaryInputBasicCluster::WriteAttributePresentValue(Callback::Cancela return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); } -CHIP_ERROR BinaryInputBasicCluster::ConfigureAttributePresentValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR BinaryInputBasicCluster::SubscribeAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -1195,11 +1194,10 @@ CHIP_ERROR BinaryInputBasicCluster::ReadAttributeStatusFlags(Callback::Cancelabl BasicAttributeFilter); } -CHIP_ERROR BinaryInputBasicCluster::ConfigureAttributeStatusFlags(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR BinaryInputBasicCluster::SubscribeAttributeStatusFlags(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -2491,11 +2489,10 @@ CHIP_ERROR ColorControlCluster::ReadAttributeCurrentHue(Callback::Cancelable * o BasicAttributeFilter); } -CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR ColorControlCluster::SubscribeAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -2522,11 +2519,10 @@ CHIP_ERROR ColorControlCluster::ReadAttributeCurrentSaturation(Callback::Cancela BasicAttributeFilter); } -CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR ColorControlCluster::SubscribeAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -2565,11 +2561,10 @@ CHIP_ERROR ColorControlCluster::ReadAttributeCurrentX(Callback::Cancelable * onS BasicAttributeFilter); } -CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentX(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR ColorControlCluster::SubscribeAttributeCurrentX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -2596,11 +2591,10 @@ CHIP_ERROR ColorControlCluster::ReadAttributeCurrentY(Callback::Cancelable * onS BasicAttributeFilter); } -CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentY(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR ColorControlCluster::SubscribeAttributeCurrentY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -2651,11 +2645,10 @@ CHIP_ERROR ColorControlCluster::ReadAttributeColorTemperature(Callback::Cancelab BasicAttributeFilter); } -CHIP_ERROR ColorControlCluster::ConfigureAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR ColorControlCluster::SubscribeAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -4669,11 +4662,10 @@ CHIP_ERROR DoorLockCluster::ReadAttributeLockState(Callback::Cancelable * onSucc BasicAttributeFilter); } -CHIP_ERROR DoorLockCluster::ConfigureAttributeLockState(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR DoorLockCluster::SubscribeAttributeLockState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -6185,11 +6177,10 @@ CHIP_ERROR LevelControlCluster::ReadAttributeCurrentLevel(Callback::Cancelable * BasicAttributeFilter); } -CHIP_ERROR LevelControlCluster::ConfigureAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR LevelControlCluster::SubscribeAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -7739,11 +7730,10 @@ CHIP_ERROR OccupancySensingCluster::ReadAttributeOccupancy(Callback::Cancelable BasicAttributeFilter); } -CHIP_ERROR OccupancySensingCluster::ConfigureAttributeOccupancy(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR OccupancySensingCluster::SubscribeAttributeOccupancy(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -8047,10 +8037,9 @@ CHIP_ERROR OnOffCluster::ReadAttributeOnOff(Callback::Cancelable * onSuccessCall BasicAttributeFilter); } -CHIP_ERROR OnOffCluster::ConfigureAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, +CHIP_ERROR OnOffCluster::SubscribeAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -8830,11 +8819,10 @@ CHIP_ERROR PressureMeasurementCluster::ReadAttributeMeasuredValue(Callback::Canc BasicAttributeFilter); } -CHIP_ERROR PressureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR PressureMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -8959,12 +8947,10 @@ CHIP_ERROR PumpConfigurationAndControlCluster::ReadAttributeCapacity(Callback::C BasicAttributeFilter); } -CHIP_ERROR PumpConfigurationAndControlCluster::ConfigureAttributeCapacity(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR PumpConfigurationAndControlCluster::SubscribeAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -9034,12 +9020,10 @@ CHIP_ERROR RelativeHumidityMeasurementCluster::ReadAttributeMeasuredValue(Callba BasicAttributeFilter); } -CHIP_ERROR RelativeHumidityMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR RelativeHumidityMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -9590,11 +9574,10 @@ CHIP_ERROR SwitchCluster::ReadAttributeCurrentPosition(Callback::Cancelable * on BasicAttributeFilter); } -CHIP_ERROR SwitchCluster::ConfigureAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR SwitchCluster::SubscribeAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -9880,12 +9863,10 @@ CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMeasuredValue(Callback::C BasicAttributeFilter); } -CHIP_ERROR TemperatureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR TemperatureMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -11045,11 +11026,10 @@ CHIP_ERROR ThermostatCluster::ReadAttributeLocalTemperature(Callback::Cancelable BasicAttributeFilter); } -CHIP_ERROR ThermostatCluster::ConfigureAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR ThermostatCluster::SubscribeAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, int16_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -12804,12 +12784,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeCurrentPositionLiftPercentage(Cal BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint8_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -12836,12 +12814,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeCurrentPositionTiltPercentage(Cal BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint8_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -12868,11 +12844,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeOperationalStatus(Callback::Cance BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -12899,12 +12874,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeTargetPositionLiftPercent100ths(C BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -12931,12 +12904,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeTargetPositionTiltPercent100ths(C BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -12975,12 +12946,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeCurrentPositionLiftPercent100ths( BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -13007,12 +12976,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeCurrentPositionTiltPercent100ths( BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - uint16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -13116,11 +13083,10 @@ CHIP_ERROR WindowCoveringCluster::ReadAttributeSafetyStatus(Callback::Cancelable BasicAttributeFilter); } -CHIP_ERROR WindowCoveringCluster::ConfigureAttributeSafetyStatus(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR WindowCoveringCluster::SubscribeAttributeSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval) { - chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h index 1e2d64a17fd0b3..cb0023bd8fe4b8 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h @@ -207,10 +207,10 @@ class DLL_EXPORT BinaryInputBasicCluster : public ClusterBase bool value); CHIP_ERROR WriteAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, bool value); - CHIP_ERROR ConfigureAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + CHIP_ERROR SubscribeAttributePresentValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributePresentValue(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeStatusFlags(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); }; @@ -403,22 +403,22 @@ class DLL_EXPORT ColorControlCluster : public ClusterBase Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR WriteAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t value); - CHIP_ERROR ConfigureAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint8_t change); + CHIP_ERROR SubscribeAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentHue(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentSaturation(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeCurrentX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint16_t change); + CHIP_ERROR SubscribeAttributeCurrentX(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentX(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeCurrentY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint16_t change); + CHIP_ERROR SubscribeAttributeCurrentY(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentY(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeColorTemperature(Callback::Cancelable * onReportCallback); private: @@ -525,7 +525,7 @@ class DLL_EXPORT DoorLockCluster : public ClusterBase 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 ConfigureAttributeLockState(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); @@ -733,8 +733,8 @@ 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 ConfigureAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint8_t change); + CHIP_ERROR SubscribeAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentLevel(Callback::Cancelable * onReportCallback); private: @@ -899,7 +899,7 @@ class DLL_EXPORT OccupancySensingCluster : public ClusterBase CHIP_ERROR ReadAttributeOccupancySensorTypeBitmap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ConfigureAttributeOccupancy(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); }; @@ -934,7 +934,7 @@ class DLL_EXPORT OnOffCluster : public ClusterBase uint16_t value); CHIP_ERROR WriteAttributeStartUpOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR ConfigureAttributeOnOff(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); @@ -1023,8 +1023,8 @@ class DLL_EXPORT PressureMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -1047,8 +1047,8 @@ class DLL_EXPORT PumpConfigurationAndControlCluster : public ClusterBase CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR ConfigureAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCapacity(Callback::Cancelable * onReportCallback); }; @@ -1063,8 +1063,8 @@ class DLL_EXPORT RelativeHumidityMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -1131,8 +1131,8 @@ class DLL_EXPORT SwitchCluster : public ClusterBase CHIP_ERROR ReadAttributeNumberOfPositions(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); - CHIP_ERROR ConfigureAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint8_t change); + CHIP_ERROR SubscribeAttributeCurrentPosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPosition(Callback::Cancelable * onReportCallback); }; @@ -1186,8 +1186,8 @@ class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -1346,9 +1346,9 @@ class DLL_EXPORT ThermostatCluster : public ClusterBase Callback::Cancelable * onFailureCallback, uint8_t value); CHIP_ERROR WriteAttributeSystemMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR ConfigureAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, int16_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeLocalTemperature(Callback::Cancelable * onReportCallback); private: @@ -1549,35 +1549,35 @@ class DLL_EXPORT WindowCoveringCluster : public ClusterBase CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR ConfigureAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionLiftPercentage(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionTiltPercentage(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeOperationalStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeOperationalStatus(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeTargetPositionLiftPercent100ths(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeTargetPositionTiltPercent100ths(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionLiftPercent100ths(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, + CHIP_ERROR SubscribeAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint16_t change); + uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentPositionTiltPercent100ths(Callback::Cancelable * onReportCallback); - CHIP_ERROR ConfigureAttributeSafetyStatus(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); diff --git a/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp b/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp index 1bd21851b35b88..f71cdfd3c67360 100644 --- a/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp @@ -58,11 +58,10 @@ CHIP_ERROR FlowMeasurementCluster::ReadAttributeMeasuredValue(Callback::Cancelab BasicAttributeFilter); } -CHIP_ERROR FlowMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR FlowMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, int16_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -127,11 +126,10 @@ CHIP_ERROR PressureMeasurementCluster::ReadAttributeMeasuredValue(Callback::Canc BasicAttributeFilter); } -CHIP_ERROR PressureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR PressureMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -196,12 +194,10 @@ CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMeasuredValue(Callback::C BasicAttributeFilter); } -CHIP_ERROR TemperatureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR TemperatureMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; diff --git a/zzz_generated/pump-app/zap-generated/CHIPClusters.h b/zzz_generated/pump-app/zap-generated/CHIPClusters.h index 5b0a1f53a33a04..571b2630f6fb3f 100644 --- a/zzz_generated/pump-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/pump-app/zap-generated/CHIPClusters.h @@ -41,8 +41,8 @@ class DLL_EXPORT FlowMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -57,8 +57,8 @@ class DLL_EXPORT PressureMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -73,8 +73,8 @@ class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; diff --git a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp index 9e87b2bbc094e2..928d35f12440e5 100644 --- a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp @@ -58,11 +58,10 @@ CHIP_ERROR FlowMeasurementCluster::ReadAttributeMeasuredValue(Callback::Cancelab BasicAttributeFilter); } -CHIP_ERROR FlowMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR FlowMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, int16_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -484,11 +483,10 @@ CHIP_ERROR LevelControlCluster::ReadAttributeCurrentLevel(Callback::Cancelable * BasicAttributeFilter); } -CHIP_ERROR LevelControlCluster::ConfigureAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR LevelControlCluster::SubscribeAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, - uint16_t maxInterval, uint8_t change) + uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -668,11 +666,10 @@ CHIP_ERROR PressureMeasurementCluster::ReadAttributeMeasuredValue(Callback::Canc BasicAttributeFilter); } -CHIP_ERROR PressureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR PressureMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -797,12 +794,10 @@ CHIP_ERROR PumpConfigurationAndControlCluster::ReadAttributeCapacity(Callback::C BasicAttributeFilter); } -CHIP_ERROR PumpConfigurationAndControlCluster::ConfigureAttributeCapacity(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR PumpConfigurationAndControlCluster::SubscribeAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; @@ -872,12 +867,10 @@ CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMeasuredValue(Callback::C BasicAttributeFilter); } -CHIP_ERROR TemperatureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, +CHIP_ERROR TemperatureMeasurementCluster::SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, - int16_t change) + uint16_t minInterval, uint16_t maxInterval) { - IgnoreUnusedVariable(change); chip::app::AttributePathParams attributePath; attributePath.mEndpointId = mEndpoint; attributePath.mClusterId = mClusterId; diff --git a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h index b8a4ade7078f54..eb764ca88d1482 100644 --- a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h @@ -41,8 +41,8 @@ class DLL_EXPORT FlowMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -72,8 +72,8 @@ 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 ConfigureAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, uint8_t change); + CHIP_ERROR SubscribeAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCurrentLevel(Callback::Cancelable * onReportCallback); private: @@ -108,8 +108,8 @@ class DLL_EXPORT PressureMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); }; @@ -132,8 +132,8 @@ class DLL_EXPORT PumpConfigurationAndControlCluster : public ClusterBase CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeOperationMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t value); - CHIP_ERROR ConfigureAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeCapacity(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeCapacity(Callback::Cancelable * onReportCallback); }; @@ -148,8 +148,8 @@ class DLL_EXPORT TemperatureMeasurementCluster : public ClusterBase 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 ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t minInterval, uint16_t maxInterval, int16_t change); + CHIP_ERROR SubscribeAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback); };