From 3392553ae317e27dfd82341a66f1d2d5123c2400 Mon Sep 17 00:00:00 2001 From: fesseha-eve <88329315+fessehaeve@users.noreply.github.com> Date: Thu, 16 Nov 2023 08:55:55 +0100 Subject: [PATCH] XMLs for valve configuration and control cluster, and boolean sensor configuration cluster & device types (#29787) Co-authored-by: Boris Zbarsky --- src/app/util/util.cpp | 2 + src/app/zap-templates/zcl/data-model/all.xml | 2 + .../boolean-sensor-configuration-cluster.xml | 71 + .../zcl/data-model/chip/matter-devices.xml | 48 + ...alve-configuration-and-control-cluster.xml | 99 + .../zcl/zcl-with-test-extensions.json | 2 + src/app/zap-templates/zcl/zcl.json | 2 + src/app/zap_cluster_list.json | 4 + .../data_model/controller-clusters.matter | 107 + .../chip/devicecontroller/ChipClusters.java | 895 + .../devicecontroller/ChipEventStructs.java | 153 + .../devicecontroller/ClusterIDMapping.java | 279 + .../devicecontroller/ClusterInfoMapping.java | 422 + .../devicecontroller/ClusterReadMapping.java | 296 + .../devicecontroller/ClusterWriteMapping.java | 114 + ...igurationClusterAlarmsStateChangedEvent.kt | 74 + ...urationAndControlClusterValveFaultEvent.kt | 55 + ...AndControlClusterValveStateChangedEvent.kt | 55 + .../chip/devicecontroller/cluster/files.gni | 3 + .../BooleanSensorConfigurationCluster.kt | 153 + .../ValveConfigurationAndControlCluster.kt | 266 + ...igurationClusterAlarmsStateChangedEvent.kt | 74 + ...urationAndControlClusterValveFaultEvent.kt | 55 + ...AndControlClusterValveStateChangedEvent.kt | 55 + .../matter/devicecontroller/cluster/files.gni | 5 + .../CHIPAttributeTLVValueDecoder.cpp | 564 + .../java/zap-generated/CHIPClientCallbacks.h | 16 + .../zap-generated/CHIPClustersWrite-JNI.cpp | 276 + .../CHIPEventTLVValueDecoder.cpp | 174 + .../java/zap-generated/CHIPReadCallbacks.cpp | 1125 + .../chip/devicecontroller/ChipClusters.java | 40492 ++++++++++++++++ .../python/chip/clusters/CHIPClusters.py | 209 + .../python/chip/clusters/Objects.py | 678 + .../MTRAttributeSpecifiedCheck.mm | 102 + .../MTRAttributeTLVValueDecoder.mm | 216 + .../CHIP/zap-generated/MTRBaseClusters.h | 278 + .../CHIP/zap-generated/MTRBaseClusters.mm | 1196 + .../CHIP/zap-generated/MTRClusterConstants.h | 48 + .../CHIP/zap-generated/MTRClusters.h | 118 + .../CHIP/zap-generated/MTRClusters.mm | 305 + .../zap-generated/MTRCommandPayloadsObjc.h | 120 + .../zap-generated/MTRCommandPayloadsObjc.mm | 322 + .../MTRCommandPayloads_Internal.h | 24 + .../zap-generated/MTRCommandTimedCheck.mm | 24 + .../zap-generated/MTRDeviceTypeMetadata.mm | 3 + .../zap-generated/MTREventTLVValueDecoder.mm | 101 + .../CHIP/zap-generated/MTRStructsObjc.h | 20 + .../CHIP/zap-generated/MTRStructsObjc.mm | 107 + .../zap-generated/attributes/Accessors.cpp | 755 + .../zap-generated/attributes/Accessors.h | 129 + .../app-common/zap-generated/callback.h | 193 + .../zap-generated/cluster-enums-check.h | 27 + .../app-common/zap-generated/cluster-enums.h | 62 + .../zap-generated/cluster-objects.cpp | 364 + .../zap-generated/cluster-objects.h | 605 + .../app-common/zap-generated/ids/Attributes.h | 116 + .../app-common/zap-generated/ids/Clusters.h | 6 + .../app-common/zap-generated/ids/Commands.h | 28 + .../app-common/zap-generated/ids/Events.h | 28 + .../app-common/zap-generated/print-cluster.h | 17 + .../zap-generated/cluster/Commands.h | 384 + .../cluster/logging/DataModelLogger.cpp | 238 + .../cluster/logging/DataModelLogger.h | 10 + .../zap-generated/cluster/Commands.h | 2863 ++ 64 files changed, 55634 insertions(+) create mode 100644 src/app/zap-templates/zcl/data-model/chip/boolean-sensor-configuration-cluster.xml create mode 100644 src/app/zap-templates/zcl/data-model/chip/valve-configuration-and-control-cluster.xml create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BooleanSensorConfigurationCluster.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ValveConfigurationAndControlCluster.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt create mode 100644 src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java diff --git a/src/app/util/util.cpp b/src/app/util/util.cpp index 619ecdcd923dcc..1add78990aa7e9 100644 --- a/src/app/util/util.cpp +++ b/src/app/util/util.cpp @@ -158,6 +158,8 @@ void MatterRefrigeratorAndTemperatureControlledCabinetModePluginServerInitCallba void MatterOperationalStatePluginServerInitCallback() {} void MatterRvcOperationalStatePluginServerInitCallback() {} void MatterDishwasherAlarmPluginServerInitCallback() {} +void MatterBooleanSensorConfigurationPluginServerInitCallback() {} +void MatterValveConfigurationAndControlPluginServerInitCallback() {} // **************************************** // Print out information about each cluster // **************************************** diff --git a/src/app/zap-templates/zcl/data-model/all.xml b/src/app/zap-templates/zcl/data-model/all.xml index 63cd2e9146a6b1..6de1433633288f 100644 --- a/src/app/zap-templates/zcl/data-model/all.xml +++ b/src/app/zap-templates/zcl/data-model/all.xml @@ -10,6 +10,7 @@ + @@ -85,6 +86,7 @@ + diff --git a/src/app/zap-templates/zcl/data-model/chip/boolean-sensor-configuration-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/boolean-sensor-configuration-cluster.xml new file mode 100644 index 00000000000000..44bb181f2b9d59 --- /dev/null +++ b/src/app/zap-templates/zcl/data-model/chip/boolean-sensor-configuration-cluster.xml @@ -0,0 +1,71 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + Boolean Sensor Configuration + Measurement & Sensing + 0x0080 + BOOLEAN_SENSOR_CONFIGURATION_CLUSTER + true + true + This cluster is used to configure a boolean sensor. + + + SensitivityLevel + AlarmsActive + AlarmsSuppressed + AlarmsEnabled + + + This command is used to suppress the specified alarm. + + + + + This event SHALL be generated when any bits in the AlarmsActive and/or AlarmsSuppressed attributes change. + + + + + + This event SHALL be generated when the device detects a sensor fault. + + + diff --git a/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml b/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml index b88f9cd12943cb..03cb6da5199103 100644 --- a/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml +++ b/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml @@ -2032,6 +2032,54 @@ limitations under the License. + + MA-boolean-sensor + CHIP + Matter Boolean Sensor + 0x0103 + 0x0041 + Simple + Endpoint + + + + + TAG_LIST + + + + + MA-valve + CHIP + Matter Valve + 0x0103 + 0x0042 + Simple + Endpoint + + + + + + + + MA-water-leak-detector + CHIP + Matter Water Leak Detector + 0x0103 + 0x0043 + Simple + Endpoint + Matter Boolean Sensor + + + + + + TAG_LIST + + + MA-all-clusters-app CHIP diff --git a/src/app/zap-templates/zcl/data-model/chip/valve-configuration-and-control-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/valve-configuration-and-control-cluster.xml new file mode 100644 index 00000000000000..d4207d6f116e2f --- /dev/null +++ b/src/app/zap-templates/zcl/data-model/chip/valve-configuration-and-control-cluster.xml @@ -0,0 +1,99 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + Valve Configuration and Control + HVAC + 0x0081 + VALVE_CONFIGURATION_AND_CONTROL_CLUSTER + true + true + This cluster is used to configure a valve. + + + + + + OpenDuration + + + + AutoCloseTime + RemainingDuration + CurrentState + TargetState + + StartUpState + + + + CurrentLevel + TargetLevel + + OpenLevel + + + + ValveFault + + + This command is used to set the valve to its fully open position. + + + + + This command is used to set the valve to its fully closed position. + + + + This command is used to set the valve to a specific level. + + + + + + This event SHALL be generated when the valve changes state, either opens or closes. + + + + + This event SHALL be generated when the valve registers a fault. + + + + diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json index ea2d302d5c167d..968c8edc15f069 100644 --- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json +++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json @@ -24,6 +24,7 @@ "barrier-control-cluster.xml", "basic-information-cluster.xml", "binding-cluster.xml", + "boolean-sensor-configuration-cluster.xml", "boolean-state-cluster.xml", "actions-cluster.xml", "bridged-device-basic-information.xml", @@ -104,6 +105,7 @@ "timer-cluster.xml", "user-label-cluster.xml", "unit-localization-cluster.xml", + "valve-configuration-and-control-cluster.xml", "wake-on-lan-cluster.xml", "washer-controls-cluster.xml", "wifi-network-diagnostics-cluster.xml", diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json index 004bc03c9c8692..185780bc1a966c 100644 --- a/src/app/zap-templates/zcl/zcl.json +++ b/src/app/zap-templates/zcl/zcl.json @@ -23,6 +23,7 @@ "barrier-control-cluster.xml", "basic-information-cluster.xml", "binding-cluster.xml", + "boolean-sensor-configuration-cluster.xml", "boolean-state-cluster.xml", "actions-cluster.xml", "bridged-device-basic-information.xml", @@ -102,6 +103,7 @@ "timer-cluster.xml", "user-label-cluster.xml", "unit-localization-cluster.xml", + "valve-configuration-and-control-cluster.xml", "wake-on-lan-cluster.xml", "washer-controls-cluster.xml", "wifi-network-diagnostics-cluster.xml", diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json index 694996b2339a7c..0711f6abb81fca 100644 --- a/src/app/zap_cluster_list.json +++ b/src/app/zap_cluster_list.json @@ -15,6 +15,7 @@ "BASIC_INFORMATION_CLUSTER": [], "BINARY_INPUT_BASIC_CLUSTER": [], "BINDING_CLUSTER": [], + "BOOLEAN_SENSOR_CONFIGURATION_CLUSTER": [], "BOOLEAN_STATE_CLUSTER": [], "BRIDGED_DEVICE_BASIC_INFORMATION_CLUSTER": [], "CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], @@ -110,6 +111,7 @@ "UNIT_TESTING_CLUSTER": [], "USER_LABEL_CLUSTER": [], "TVOC_CONCENTRATION_MEASUREMENT_CLUSTER": [], + "VALVE_CONFIGURATION_AND_CONTROL_CLUSTER": [], "WAKE_ON_LAN_CLUSTER": [], "LAUNDRY_WASHER_CONTROLS_CLUSTER": [], "WIFI_NETWORK_DIAGNOSTICS_CLUSTER": [], @@ -136,6 +138,7 @@ "BASIC_INFORMATION_CLUSTER": ["basic-information"], "BINARY_INPUT_BASIC_CLUSTER": [], "BINDING_CLUSTER": ["bindings"], + "BOOLEAN_SENSOR_CONFIGURATION_CLUSTER": [], "BOOLEAN_STATE_CLUSTER": [], "BRIDGED_DEVICE_BASIC_INFORMATION_CLUSTER": [ "bridged-device-basic-information-server" @@ -263,6 +266,7 @@ "UNIT_LOCALIZATION_CLUSTER": [], "UNIT_TESTING_CLUSTER": ["test-cluster-server"], "USER_LABEL_CLUSTER": ["user-label-server"], + "VALVE_CONFIGURATION_AND_CONTROL_CLUSTER": [], "WAKE_ON_LAN_CLUSTER": ["wake-on-lan-server"], "LAUNDRY_WASHER_CONTROLS_CLUSTER": ["laundry-washer-controls-server"], "WIFI_NETWORK_DIAGNOSTICS_CLUSTER": ["wifi-network-diagnostics-server"], diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index b0d13229b3c9ec..6ae38946c6da62 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -3715,6 +3715,113 @@ client cluster ActivatedCarbonFilterMonitoring = 114 { command ResetCondition(): DefaultSuccess = 0; } +/** This cluster is used to configure a boolean sensor. */ +provisional client cluster BooleanSensorConfiguration = 128 { + enum SensitivityEnum : enum8 { + kHigh = 0; + kStandard = 1; + kLow = 2; + } + + bitmap AlarmModeBitmap : bitmap8 { + kVisual = 0x1; + kAudible = 0x2; + } + + bitmap Feature : bitmap32 { + kVisual = 0x1; + kAudible = 0x2; + kAlarmSuppress = 0x4; + kSensitivityLevel = 0x8; + } + + info event AlarmsStateChanged = 0 { + AlarmModeBitmap alarmsActive = 0; + optional AlarmModeBitmap alarmsSuppressed = 1; + } + + info event SensorFault = 1 { + } + + attribute optional SensitivityEnum sensitivityLevel = 0; + readonly attribute optional AlarmModeBitmap alarmsActive = 1; + readonly attribute optional AlarmModeBitmap alarmsSuppressed = 2; + attribute optional AlarmModeBitmap alarmsEnabled = 3; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct SuppressRequestRequest { + AlarmModeBitmap alarmsToSuppress = 0; + } + + /** This command is used to suppress the specified alarm. */ + command SuppressRequest(SuppressRequestRequest): DefaultSuccess = 0; +} + +/** This cluster is used to configure a valve. */ +provisional client cluster ValveConfigurationAndControl = 129 { + enum ValveStateEnum : enum8 { + kOpen = 0; + kClosed = 1; + } + + bitmap Feature : bitmap32 { + kTimeSync = 0x1; + kLevel = 0x2; + } + + bitmap ValveFaultBitmap : bitmap16 { + kGeneralFault = 0x1; + kBlocked = 0x2; + kLeaking = 0x4; + } + + info event ValveStateChanged = 0 { + ValveStateEnum valveState = 0; + } + + info event ValveFault = 1 { + ValveFaultBitmap valveFault = 0; + } + + attribute access(write: manage) nullable elapsed_s openDuration = 0; + readonly attribute optional nullable epoch_us autoCloseTime = 1; + readonly attribute optional nullable elapsed_s remainingDuration = 2; + readonly attribute nullable ValveStateEnum currentState = 3; + readonly attribute nullable ValveStateEnum targetState = 4; + attribute access(write: manage) optional ValveStateEnum startUpState = 5; + readonly attribute optional nullable percent currentLevel = 6; + readonly attribute optional nullable percent targetLevel = 7; + attribute access(write: manage) optional nullable percent openLevel = 8; + readonly attribute optional ValveFaultBitmap valveFault = 9; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct OpenRequest { + optional elapsed_s openDuration = 0; + } + + request struct SetLevelRequest { + percent level = 0; + optional elapsed_s openDuration = 1; + } + + /** This command is used to set the valve to its fully open position. */ + command Open(OpenRequest): DefaultSuccess = 0; + /** This command is used to set the valve to its fully closed position. */ + command Close(): DefaultSuccess = 1; + /** This command is used to set the valve to a specific level. */ + command SetLevel(SetLevelRequest): DefaultSuccess = 2; +} + /** This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. */ client cluster DemandResponseLoadControl = 150 { enum CriticalityLevelEnum : enum8 { diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java index 8d50cbbd76758f..a36a025da1ff87 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java @@ -26252,6 +26252,901 @@ public void onSuccess(byte[] tlv) { } } + public static class BooleanSensorConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 128L; + + private static final long SENSITIVITY_LEVEL_ATTRIBUTE_ID = 0L; + private static final long ALARMS_ACTIVE_ATTRIBUTE_ID = 1L; + private static final long ALARMS_SUPPRESSED_ATTRIBUTE_ID = 2L; + private static final long ALARMS_ENABLED_ATTRIBUTE_ID = 3L; + private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L; + private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L; + private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L; + private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L; + private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L; + private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L; + + public BooleanSensorConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId, CLUSTER_ID); + } + + @Override + @Deprecated + public long initWithDevice(long devicePtr, int endpointId) { + return 0L; + } + + public void suppressRequest(DefaultClusterCallback callback, Integer alarmsToSuppress) { + suppressRequest(callback, alarmsToSuppress, 0); + } + + public void suppressRequest(DefaultClusterCallback callback, Integer alarmsToSuppress, int timedInvokeTimeoutMs) { + final long commandId = 0L; + + ArrayList elements = new ArrayList<>(); + final long alarmsToSuppressFieldID = 0L; + BaseTLVType alarmsToSuppresstlvValue = new UIntType(alarmsToSuppress); + elements.add(new StructElement(alarmsToSuppressFieldID, alarmsToSuppresstlvValue)); + + StructType value = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + callback.onSuccess(); + }}, commandId, value, timedInvokeTimeoutMs); + } + + public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface EventListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface AttributeListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public void readSensitivityLevelAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SENSITIVITY_LEVEL_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, SENSITIVITY_LEVEL_ATTRIBUTE_ID, true); + } + + public void writeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeSensitivityLevelAttribute(callback, value, 0); + } + + public void writeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = new UIntType(value); + writeAttribute(new WriteAttributesCallbackImpl(callback), SENSITIVITY_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeSensitivityLevelAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SENSITIVITY_LEVEL_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, SENSITIVITY_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAlarmsActiveAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALARMS_ACTIVE_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ALARMS_ACTIVE_ATTRIBUTE_ID, true); + } + + public void subscribeAlarmsActiveAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALARMS_ACTIVE_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ALARMS_ACTIVE_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAlarmsSuppressedAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALARMS_SUPPRESSED_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ALARMS_SUPPRESSED_ATTRIBUTE_ID, true); + } + + public void subscribeAlarmsSuppressedAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALARMS_SUPPRESSED_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ALARMS_SUPPRESSED_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAlarmsEnabledAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALARMS_ENABLED_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ALARMS_ENABLED_ATTRIBUTE_ID, true); + } + + public void writeAlarmsEnabledAttribute(DefaultClusterCallback callback, Integer value) { + writeAlarmsEnabledAttribute(callback, value, 0); + } + + public void writeAlarmsEnabledAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = new UIntType(value); + writeAttribute(new WriteAttributesCallbackImpl(callback), ALARMS_ENABLED_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeAlarmsEnabledAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALARMS_ENABLED_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ALARMS_ENABLED_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, EVENT_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeEventListAttribute( + EventListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, FEATURE_MAP_ATTRIBUTE_ID, true); + } + + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CLUSTER_REVISION_ATTRIBUTE_ID, true); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval); + } + } + + public static class ValveConfigurationAndControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 129L; + + private static final long OPEN_DURATION_ATTRIBUTE_ID = 0L; + private static final long AUTO_CLOSE_TIME_ATTRIBUTE_ID = 1L; + private static final long REMAINING_DURATION_ATTRIBUTE_ID = 2L; + private static final long CURRENT_STATE_ATTRIBUTE_ID = 3L; + private static final long TARGET_STATE_ATTRIBUTE_ID = 4L; + private static final long START_UP_STATE_ATTRIBUTE_ID = 5L; + private static final long CURRENT_LEVEL_ATTRIBUTE_ID = 6L; + private static final long TARGET_LEVEL_ATTRIBUTE_ID = 7L; + private static final long OPEN_LEVEL_ATTRIBUTE_ID = 8L; + private static final long VALVE_FAULT_ATTRIBUTE_ID = 9L; + private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L; + private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L; + private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L; + private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L; + private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L; + private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L; + + public ValveConfigurationAndControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId, CLUSTER_ID); + } + + @Override + @Deprecated + public long initWithDevice(long devicePtr, int endpointId) { + return 0L; + } + + public void open(DefaultClusterCallback callback, Optional openDuration) { + open(callback, openDuration, 0); + } + + public void open(DefaultClusterCallback callback, Optional openDuration, int timedInvokeTimeoutMs) { + final long commandId = 0L; + + ArrayList elements = new ArrayList<>(); + final long openDurationFieldID = 0L; + BaseTLVType openDurationtlvValue = openDuration.map((nonOptionalopenDuration) -> new UIntType(nonOptionalopenDuration)).orElse(new EmptyType()); + elements.add(new StructElement(openDurationFieldID, openDurationtlvValue)); + + StructType value = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + callback.onSuccess(); + }}, commandId, value, timedInvokeTimeoutMs); + } + + public void close(DefaultClusterCallback callback) { + close(callback, 0); + } + + public void close(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + final long commandId = 1L; + + ArrayList elements = new ArrayList<>(); + StructType value = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + callback.onSuccess(); + }}, commandId, value, timedInvokeTimeoutMs); + } + + public void setLevel(DefaultClusterCallback callback, Integer level, Optional openDuration) { + setLevel(callback, level, openDuration, 0); + } + + public void setLevel(DefaultClusterCallback callback, Integer level, Optional openDuration, int timedInvokeTimeoutMs) { + final long commandId = 2L; + + ArrayList elements = new ArrayList<>(); + final long levelFieldID = 0L; + BaseTLVType leveltlvValue = new UIntType(level); + elements.add(new StructElement(levelFieldID, leveltlvValue)); + + final long openDurationFieldID = 1L; + BaseTLVType openDurationtlvValue = openDuration.map((nonOptionalopenDuration) -> new UIntType(nonOptionalopenDuration)).orElse(new EmptyType()); + elements.add(new StructElement(openDurationFieldID, openDurationtlvValue)); + + StructType value = new StructType(elements); + invoke(new InvokeCallbackImpl(callback) { + @Override + public void onResponse(StructType invokeStructValue) { + callback.onSuccess(); + }}, commandId, value, timedInvokeTimeoutMs); + } + + public interface OpenDurationAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Long value); + } + + public interface AutoCloseTimeAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Long value); + } + + public interface RemainingDurationAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Long value); + } + + public interface CurrentStateAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Integer value); + } + + public interface TargetStateAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Integer value); + } + + public interface CurrentLevelAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Integer value); + } + + public interface TargetLevelAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Integer value); + } + + public interface OpenLevelAttributeCallback extends BaseAttributeCallback { + void onSuccess(@Nullable Integer value); + } + + public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface EventListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface AttributeListAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public void readOpenDurationAttribute( + OpenDurationAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPEN_DURATION_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, OPEN_DURATION_ATTRIBUTE_ID, true); + } + + public void writeOpenDurationAttribute(DefaultClusterCallback callback, Long value) { + writeOpenDurationAttribute(callback, value, 0); + } + + public void writeOpenDurationAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType(); + writeAttribute(new WriteAttributesCallbackImpl(callback), OPEN_DURATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeOpenDurationAttribute( + OpenDurationAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPEN_DURATION_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, OPEN_DURATION_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAutoCloseTimeAttribute( + AutoCloseTimeAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AUTO_CLOSE_TIME_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, AUTO_CLOSE_TIME_ATTRIBUTE_ID, true); + } + + public void subscribeAutoCloseTimeAttribute( + AutoCloseTimeAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AUTO_CLOSE_TIME_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, AUTO_CLOSE_TIME_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readRemainingDurationAttribute( + RemainingDurationAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_DURATION_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, REMAINING_DURATION_ATTRIBUTE_ID, true); + } + + public void subscribeRemainingDurationAttribute( + RemainingDurationAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_DURATION_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, REMAINING_DURATION_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readCurrentStateAttribute( + CurrentStateAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_STATE_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CURRENT_STATE_ATTRIBUTE_ID, true); + } + + public void subscribeCurrentStateAttribute( + CurrentStateAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_STATE_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, CURRENT_STATE_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readTargetStateAttribute( + TargetStateAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_STATE_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, TARGET_STATE_ATTRIBUTE_ID, true); + } + + public void subscribeTargetStateAttribute( + TargetStateAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_STATE_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, TARGET_STATE_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readStartUpStateAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_STATE_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, START_UP_STATE_ATTRIBUTE_ID, true); + } + + public void writeStartUpStateAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpStateAttribute(callback, value, 0); + } + + public void writeStartUpStateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = new UIntType(value); + writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_STATE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeStartUpStateAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_STATE_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, START_UP_STATE_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readCurrentLevelAttribute( + CurrentLevelAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LEVEL_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CURRENT_LEVEL_ATTRIBUTE_ID, true); + } + + public void subscribeCurrentLevelAttribute( + CurrentLevelAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LEVEL_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, CURRENT_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readTargetLevelAttribute( + TargetLevelAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_LEVEL_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, TARGET_LEVEL_ATTRIBUTE_ID, true); + } + + public void subscribeTargetLevelAttribute( + TargetLevelAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_LEVEL_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, TARGET_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readOpenLevelAttribute( + OpenLevelAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPEN_LEVEL_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, OPEN_LEVEL_ATTRIBUTE_ID, true); + } + + public void writeOpenLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeOpenLevelAttribute(callback, value, 0); + } + + public void writeOpenLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType(); + writeAttribute(new WriteAttributesCallbackImpl(callback), OPEN_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeOpenLevelAttribute( + OpenLevelAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPEN_LEVEL_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, OPEN_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readValveFaultAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VALVE_FAULT_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, VALVE_FAULT_ATTRIBUTE_ID, true); + } + + public void subscribeValveFaultAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VALVE_FAULT_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, VALVE_FAULT_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, EVENT_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeEventListAttribute( + EventListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true); + } + + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, FEATURE_MAP_ATTRIBUTE_ID, true); + } + + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CLUSTER_REVISION_ATTRIBUTE_ID, true); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval); + } + } + public static class DemandResponseLoadControlCluster extends BaseChipCluster { public static final long CLUSTER_ID = 150L; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java index 4866e8833e8013..9c48ad3dcdcb70 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java @@ -2785,6 +2785,159 @@ public String toString() { return output.toString(); } } +public static class BooleanSensorConfigurationClusterAlarmsStateChangedEvent { + public Integer alarmsActive; + public Optional alarmsSuppressed; + private static final long ALARMS_ACTIVE_ID = 0L; + private static final long ALARMS_SUPPRESSED_ID = 1L; + + public BooleanSensorConfigurationClusterAlarmsStateChangedEvent( + Integer alarmsActive, + Optional alarmsSuppressed + ) { + this.alarmsActive = alarmsActive; + this.alarmsSuppressed = alarmsSuppressed; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(ALARMS_ACTIVE_ID, new UIntType(alarmsActive))); + values.add(new StructElement(ALARMS_SUPPRESSED_ID, alarmsSuppressed.map((nonOptionalalarmsSuppressed) -> new UIntType(nonOptionalalarmsSuppressed)).orElse(new EmptyType()))); + + return new StructType(values); + } + + public static BooleanSensorConfigurationClusterAlarmsStateChangedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer alarmsActive = null; + Optional alarmsSuppressed = Optional.empty(); + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == ALARMS_ACTIVE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + alarmsActive = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == ALARMS_SUPPRESSED_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + alarmsSuppressed = Optional.of(castingValue.value(Integer.class)); + } + } + } + return new BooleanSensorConfigurationClusterAlarmsStateChangedEvent( + alarmsActive, + alarmsSuppressed + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BooleanSensorConfigurationClusterAlarmsStateChangedEvent {\n"); + output.append("\talarmsActive: "); + output.append(alarmsActive); + output.append("\n"); + output.append("\talarmsSuppressed: "); + output.append(alarmsSuppressed); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ValveConfigurationAndControlClusterValveStateChangedEvent { + public Integer valveState; + private static final long VALVE_STATE_ID = 0L; + + public ValveConfigurationAndControlClusterValveStateChangedEvent( + Integer valveState + ) { + this.valveState = valveState; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(VALVE_STATE_ID, new UIntType(valveState))); + + return new StructType(values); + } + + public static ValveConfigurationAndControlClusterValveStateChangedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer valveState = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == VALVE_STATE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + valveState = castingValue.value(Integer.class); + } + } + } + return new ValveConfigurationAndControlClusterValveStateChangedEvent( + valveState + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ValveConfigurationAndControlClusterValveStateChangedEvent {\n"); + output.append("\tvalveState: "); + output.append(valveState); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ValveConfigurationAndControlClusterValveFaultEvent { + public Integer valveFault; + private static final long VALVE_FAULT_ID = 0L; + + public ValveConfigurationAndControlClusterValveFaultEvent( + Integer valveFault + ) { + this.valveFault = valveFault; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(VALVE_FAULT_ID, new UIntType(valveFault))); + + return new StructType(values); + } + + public static ValveConfigurationAndControlClusterValveFaultEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer valveFault = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == VALVE_FAULT_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + valveFault = castingValue.value(Integer.class); + } + } + } + return new ValveConfigurationAndControlClusterValveFaultEvent( + valveFault + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ValveConfigurationAndControlClusterValveFaultEvent {\n"); + output.append("\tvalveFault: "); + output.append(valveFault); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} public static class DemandResponseLoadControlClusterLoadControlEventStatusChangeEvent { public byte[] eventID; public @Nullable Integer transitionIndex; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index a340abd92582a1..91b8ee3320b7ec 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -208,6 +208,12 @@ public static BaseCluster getCluster(long clusterId) { if (clusterId == ActivatedCarbonFilterMonitoring.ID) { return new ActivatedCarbonFilterMonitoring(); } + if (clusterId == BooleanSensorConfiguration.ID) { + return new BooleanSensorConfiguration(); + } + if (clusterId == ValveConfigurationAndControl.ID) { + return new ValveConfigurationAndControl(); + } if (clusterId == DemandResponseLoadControl.ID) { return new DemandResponseLoadControl(); } @@ -8400,6 +8406,279 @@ public long getCommandID(String name) throws IllegalArgumentException { return Command.valueOf(name).getID(); } } + public static class BooleanSensorConfiguration implements BaseCluster { + public static final long ID = 128L; + public long getID() { + return ID; + } + + public enum Attribute { + SensitivityLevel(0L), + AlarmsActive(1L), + AlarmsSuppressed(2L), + AlarmsEnabled(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + AlarmsStateChanged(0L), + SensorFault(1L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SuppressRequest(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SuppressRequestCommandField {AlarmsToSuppress(0),; + private final int id; + SuppressRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SuppressRequestCommandField value(int id) throws NoSuchFieldError { + for (SuppressRequestCommandField field : SuppressRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ValveConfigurationAndControl implements BaseCluster { + public static final long ID = 129L; + public long getID() { + return ID; + } + + public enum Attribute { + OpenDuration(0L), + AutoCloseTime(1L), + RemainingDuration(2L), + CurrentState(3L), + TargetState(4L), + StartUpState(5L), + CurrentLevel(6L), + TargetLevel(7L), + OpenLevel(8L), + ValveFault(9L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ValveStateChanged(0L), + ValveFault(1L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Open(0L), + Close(1L), + SetLevel(2L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum OpenCommandField {OpenDuration(0),; + private final int id; + OpenCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static OpenCommandField value(int id) throws NoSuchFieldError { + for (OpenCommandField field : OpenCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetLevelCommandField {Level(0),OpenDuration(1),; + private final int id; + SetLevelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetLevelCommandField value(int id) throws NoSuchFieldError { + for (SetLevelCommandField field : SetLevelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } public static class DemandResponseLoadControl implements BaseCluster { public static final long ID = 150L; public long getID() { diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java index 8f86942fe67027..dab0923ab45c54 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java @@ -9121,6 +9121,342 @@ public void onError(Exception ex) { } } + public static class DelegatedBooleanSensorConfigurationClusterGeneratedCommandListAttributeCallback implements ChipClusters.BooleanSensorConfigurationCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedBooleanSensorConfigurationClusterAcceptedCommandListAttributeCallback implements ChipClusters.BooleanSensorConfigurationCluster.AcceptedCommandListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedBooleanSensorConfigurationClusterEventListAttributeCallback implements ChipClusters.BooleanSensorConfigurationCluster.EventListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedBooleanSensorConfigurationClusterAttributeListAttributeCallback implements ChipClusters.BooleanSensorConfigurationCluster.AttributeListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterOpenDurationAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.OpenDurationAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterAutoCloseTimeAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.AutoCloseTimeAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterRemainingDurationAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.RemainingDurationAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterCurrentStateAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.CurrentStateAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterTargetStateAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.TargetStateAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterCurrentLevelAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.CurrentLevelAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterTargetLevelAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.TargetLevelAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterOpenLevelAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.OpenLevelAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(@Nullable Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterGeneratedCommandListAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterAcceptedCommandListAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.AcceptedCommandListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterEventListAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.EventListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + + public static class DelegatedValveConfigurationAndControlClusterAttributeListAttributeCallback implements ChipClusters.ValveConfigurationAndControlCluster.AttributeListAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(List valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedDemandResponseLoadControlClusterLoadControlProgramsAttributeCallback implements ChipClusters.DemandResponseLoadControlCluster.LoadControlProgramsAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -17541,6 +17877,14 @@ public Map initializeClusterMap() { (ptr, endpointId) -> new ChipClusters.ActivatedCarbonFilterMonitoringCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("activatedCarbonFilterMonitoring", activatedCarbonFilterMonitoringClusterInfo); + ClusterInfo booleanSensorConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanSensorConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("booleanSensorConfiguration", booleanSensorConfigurationClusterInfo); + + ClusterInfo valveConfigurationAndControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ValveConfigurationAndControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("valveConfigurationAndControl", valveConfigurationAndControlClusterInfo); + ClusterInfo demandResponseLoadControlClusterInfo = new ClusterInfo( (ptr, endpointId) -> new ChipClusters.DemandResponseLoadControlCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("demandResponseLoadControl", demandResponseLoadControlClusterInfo); @@ -17773,6 +18117,8 @@ public void combineCommand(Map destination, Map> getCommandMap() { commandMap.put("activatedCarbonFilterMonitoring", activatedCarbonFilterMonitoringClusterInteractionInfoMap); + Map booleanSensorConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + + Map booleanSensorConfigurationsuppressRequestCommandParams = new LinkedHashMap(); + + CommandParameterInfo booleanSensorConfigurationsuppressRequestalarmsToSuppressCommandParameterInfo = new CommandParameterInfo("alarmsToSuppress", Integer.class, Integer.class); + booleanSensorConfigurationsuppressRequestCommandParams.put("alarmsToSuppress",booleanSensorConfigurationsuppressRequestalarmsToSuppressCommandParameterInfo); + InteractionInfo booleanSensorConfigurationsuppressRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster) + .suppressRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("alarmsToSuppress") + ); + }, + () -> new DelegatedDefaultClusterCallback(), + booleanSensorConfigurationsuppressRequestCommandParams + ); + booleanSensorConfigurationClusterInteractionInfoMap.put("suppressRequest", booleanSensorConfigurationsuppressRequestInteractionInfo); + + commandMap.put("booleanSensorConfiguration", booleanSensorConfigurationClusterInteractionInfoMap); + + Map valveConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); + + Map valveConfigurationAndControlopenCommandParams = new LinkedHashMap(); + + CommandParameterInfo valveConfigurationAndControlopenopenDurationCommandParameterInfo = new CommandParameterInfo("openDuration", Optional.class, Long.class); + valveConfigurationAndControlopenCommandParams.put("openDuration",valveConfigurationAndControlopenopenDurationCommandParameterInfo); + InteractionInfo valveConfigurationAndControlopenInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster) + .open((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("openDuration") + ); + }, + () -> new DelegatedDefaultClusterCallback(), + valveConfigurationAndControlopenCommandParams + ); + valveConfigurationAndControlClusterInteractionInfoMap.put("open", valveConfigurationAndControlopenInteractionInfo); + + Map valveConfigurationAndControlcloseCommandParams = new LinkedHashMap(); + InteractionInfo valveConfigurationAndControlcloseInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster) + .close((DefaultClusterCallback) callback + ); + }, + () -> new DelegatedDefaultClusterCallback(), + valveConfigurationAndControlcloseCommandParams + ); + valveConfigurationAndControlClusterInteractionInfoMap.put("close", valveConfigurationAndControlcloseInteractionInfo); + + Map valveConfigurationAndControlsetLevelCommandParams = new LinkedHashMap(); + + CommandParameterInfo valveConfigurationAndControlsetLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class, Integer.class); + valveConfigurationAndControlsetLevelCommandParams.put("level",valveConfigurationAndControlsetLevellevelCommandParameterInfo); + + CommandParameterInfo valveConfigurationAndControlsetLevelopenDurationCommandParameterInfo = new CommandParameterInfo("openDuration", Optional.class, Long.class); + valveConfigurationAndControlsetLevelCommandParams.put("openDuration",valveConfigurationAndControlsetLevelopenDurationCommandParameterInfo); + InteractionInfo valveConfigurationAndControlsetLevelInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster) + .setLevel((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("level") + , (Optional) + commandArguments.get("openDuration") + ); + }, + () -> new DelegatedDefaultClusterCallback(), + valveConfigurationAndControlsetLevelCommandParams + ); + valveConfigurationAndControlClusterInteractionInfoMap.put("setLevel", valveConfigurationAndControlsetLevelInteractionInfo); + + commandMap.put("valveConfigurationAndControl", valveConfigurationAndControlClusterInteractionInfoMap); + Map demandResponseLoadControlClusterInteractionInfoMap = new LinkedHashMap<>(); Map demandResponseLoadControlregisterLoadControlProgramRequestCommandParams = new LinkedHashMap(); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index 4e1b64b42e125f..bee57370beb7d0 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -8284,6 +8284,300 @@ private static Map readActivatedCarbonFilterMonitoringI return result; } + private static Map readBooleanSensorConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBooleanSensorConfigurationSensitivityLevelCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationSensitivityLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readSensitivityLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanSensorConfigurationSensitivityLevelCommandParams + ); + result.put("readSensitivityLevelAttribute", readBooleanSensorConfigurationSensitivityLevelAttributeInteractionInfo); + Map readBooleanSensorConfigurationAlarmsActiveCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationAlarmsActiveAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readAlarmsActiveAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanSensorConfigurationAlarmsActiveCommandParams + ); + result.put("readAlarmsActiveAttribute", readBooleanSensorConfigurationAlarmsActiveAttributeInteractionInfo); + Map readBooleanSensorConfigurationAlarmsSuppressedCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationAlarmsSuppressedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readAlarmsSuppressedAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanSensorConfigurationAlarmsSuppressedCommandParams + ); + result.put("readAlarmsSuppressedAttribute", readBooleanSensorConfigurationAlarmsSuppressedAttributeInteractionInfo); + Map readBooleanSensorConfigurationAlarmsEnabledCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationAlarmsEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readAlarmsEnabledAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanSensorConfigurationAlarmsEnabledCommandParams + ); + result.put("readAlarmsEnabledAttribute", readBooleanSensorConfigurationAlarmsEnabledAttributeInteractionInfo); + Map readBooleanSensorConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BooleanSensorConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanSensorConfigurationClusterGeneratedCommandListAttributeCallback(), + readBooleanSensorConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBooleanSensorConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readBooleanSensorConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BooleanSensorConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanSensorConfigurationClusterAcceptedCommandListAttributeCallback(), + readBooleanSensorConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBooleanSensorConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readBooleanSensorConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.BooleanSensorConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanSensorConfigurationClusterEventListAttributeCallback(), + readBooleanSensorConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readBooleanSensorConfigurationEventListAttributeInteractionInfo); + Map readBooleanSensorConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.BooleanSensorConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanSensorConfigurationClusterAttributeListAttributeCallback(), + readBooleanSensorConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBooleanSensorConfigurationAttributeListAttributeInteractionInfo); + Map readBooleanSensorConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBooleanSensorConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBooleanSensorConfigurationFeatureMapAttributeInteractionInfo); + Map readBooleanSensorConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanSensorConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanSensorConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBooleanSensorConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readValveConfigurationAndControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readValveConfigurationAndControlOpenDurationCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlOpenDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readOpenDurationAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.OpenDurationAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterOpenDurationAttributeCallback(), + readValveConfigurationAndControlOpenDurationCommandParams + ); + result.put("readOpenDurationAttribute", readValveConfigurationAndControlOpenDurationAttributeInteractionInfo); + Map readValveConfigurationAndControlAutoCloseTimeCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlAutoCloseTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readAutoCloseTimeAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.AutoCloseTimeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterAutoCloseTimeAttributeCallback(), + readValveConfigurationAndControlAutoCloseTimeCommandParams + ); + result.put("readAutoCloseTimeAttribute", readValveConfigurationAndControlAutoCloseTimeAttributeInteractionInfo); + Map readValveConfigurationAndControlRemainingDurationCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlRemainingDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readRemainingDurationAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.RemainingDurationAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterRemainingDurationAttributeCallback(), + readValveConfigurationAndControlRemainingDurationCommandParams + ); + result.put("readRemainingDurationAttribute", readValveConfigurationAndControlRemainingDurationAttributeInteractionInfo); + Map readValveConfigurationAndControlCurrentStateCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlCurrentStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readCurrentStateAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.CurrentStateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterCurrentStateAttributeCallback(), + readValveConfigurationAndControlCurrentStateCommandParams + ); + result.put("readCurrentStateAttribute", readValveConfigurationAndControlCurrentStateAttributeInteractionInfo); + Map readValveConfigurationAndControlTargetStateCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlTargetStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readTargetStateAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.TargetStateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterTargetStateAttributeCallback(), + readValveConfigurationAndControlTargetStateCommandParams + ); + result.put("readTargetStateAttribute", readValveConfigurationAndControlTargetStateAttributeInteractionInfo); + Map readValveConfigurationAndControlStartUpStateCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlStartUpStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readStartUpStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readValveConfigurationAndControlStartUpStateCommandParams + ); + result.put("readStartUpStateAttribute", readValveConfigurationAndControlStartUpStateAttributeInteractionInfo); + Map readValveConfigurationAndControlCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readCurrentLevelAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.CurrentLevelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterCurrentLevelAttributeCallback(), + readValveConfigurationAndControlCurrentLevelCommandParams + ); + result.put("readCurrentLevelAttribute", readValveConfigurationAndControlCurrentLevelAttributeInteractionInfo); + Map readValveConfigurationAndControlTargetLevelCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlTargetLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readTargetLevelAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.TargetLevelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterTargetLevelAttributeCallback(), + readValveConfigurationAndControlTargetLevelCommandParams + ); + result.put("readTargetLevelAttribute", readValveConfigurationAndControlTargetLevelAttributeInteractionInfo); + Map readValveConfigurationAndControlOpenLevelCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlOpenLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readOpenLevelAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.OpenLevelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterOpenLevelAttributeCallback(), + readValveConfigurationAndControlOpenLevelCommandParams + ); + result.put("readOpenLevelAttribute", readValveConfigurationAndControlOpenLevelAttributeInteractionInfo); + Map readValveConfigurationAndControlValveFaultCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlValveFaultAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readValveFaultAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readValveConfigurationAndControlValveFaultCommandParams + ); + result.put("readValveFaultAttribute", readValveConfigurationAndControlValveFaultAttributeInteractionInfo); + Map readValveConfigurationAndControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterGeneratedCommandListAttributeCallback(), + readValveConfigurationAndControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readValveConfigurationAndControlGeneratedCommandListAttributeInteractionInfo); + Map readValveConfigurationAndControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterAcceptedCommandListAttributeCallback(), + readValveConfigurationAndControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readValveConfigurationAndControlAcceptedCommandListAttributeInteractionInfo); + Map readValveConfigurationAndControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readEventListAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterEventListAttributeCallback(), + readValveConfigurationAndControlEventListCommandParams + ); + result.put("readEventListAttribute", readValveConfigurationAndControlEventListAttributeInteractionInfo); + Map readValveConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.ValveConfigurationAndControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedValveConfigurationAndControlClusterAttributeListAttributeCallback(), + readValveConfigurationAndControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readValveConfigurationAndControlAttributeListAttributeInteractionInfo); + Map readValveConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readValveConfigurationAndControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readValveConfigurationAndControlFeatureMapAttributeInteractionInfo); + Map readValveConfigurationAndControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readValveConfigurationAndControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readValveConfigurationAndControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readValveConfigurationAndControlClusterRevisionAttributeInteractionInfo); + + return result; + } private static Map readDemandResponseLoadControlInteractionInfo() { Map result = new LinkedHashMap<>();Map readDemandResponseLoadControlDeviceClassCommandParams = new LinkedHashMap(); InteractionInfo readDemandResponseLoadControlDeviceClassAttributeInteractionInfo = new InteractionInfo( @@ -18020,6 +18314,8 @@ public Map> getReadAttributeMap() { put("rvcOperationalState", readRvcOperationalStateInteractionInfo()); put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo()); put("activatedCarbonFilterMonitoring", readActivatedCarbonFilterMonitoringInteractionInfo()); + put("booleanSensorConfiguration", readBooleanSensorConfigurationInteractionInfo()); + put("valveConfigurationAndControl", readValveConfigurationAndControlInteractionInfo()); put("demandResponseLoadControl", readDemandResponseLoadControlInteractionInfo()); put("doorLock", readDoorLockInteractionInfo()); put("windowCovering", readWindowCoveringInteractionInfo()); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index 2f14aa26764e42..7a07acc2cbcbf4 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -1092,6 +1092,120 @@ public Map> getWriteAttributeMap() { ); writeActivatedCarbonFilterMonitoringInteractionInfo.put("writeLastChangedTimeAttribute", writeActivatedCarbonFilterMonitoringLastChangedTimeAttributeInteractionInfo); writeAttributeMap.put("activatedCarbonFilterMonitoring", writeActivatedCarbonFilterMonitoringInteractionInfo); + Map writeBooleanSensorConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeBooleanSensorConfigurationSensitivityLevelCommandParams = new LinkedHashMap(); + CommandParameterInfo booleanSensorConfigurationsensitivityLevelCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeBooleanSensorConfigurationSensitivityLevelCommandParams.put( + "value", + booleanSensorConfigurationsensitivityLevelCommandParameterInfo + ); + InteractionInfo writeBooleanSensorConfigurationSensitivityLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).writeSensitivityLevelAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBooleanSensorConfigurationSensitivityLevelCommandParams + ); + writeBooleanSensorConfigurationInteractionInfo.put("writeSensitivityLevelAttribute", writeBooleanSensorConfigurationSensitivityLevelAttributeInteractionInfo); + Map writeBooleanSensorConfigurationAlarmsEnabledCommandParams = new LinkedHashMap(); + CommandParameterInfo booleanSensorConfigurationalarmsEnabledCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeBooleanSensorConfigurationAlarmsEnabledCommandParams.put( + "value", + booleanSensorConfigurationalarmsEnabledCommandParameterInfo + ); + InteractionInfo writeBooleanSensorConfigurationAlarmsEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanSensorConfigurationCluster) cluster).writeAlarmsEnabledAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBooleanSensorConfigurationAlarmsEnabledCommandParams + ); + writeBooleanSensorConfigurationInteractionInfo.put("writeAlarmsEnabledAttribute", writeBooleanSensorConfigurationAlarmsEnabledAttributeInteractionInfo); + writeAttributeMap.put("booleanSensorConfiguration", writeBooleanSensorConfigurationInteractionInfo); + Map writeValveConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); + Map writeValveConfigurationAndControlOpenDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo valveConfigurationAndControlopenDurationCommandParameterInfo = + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeValveConfigurationAndControlOpenDurationCommandParams.put( + "value", + valveConfigurationAndControlopenDurationCommandParameterInfo + ); + InteractionInfo writeValveConfigurationAndControlOpenDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).writeOpenDurationAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeValveConfigurationAndControlOpenDurationCommandParams + ); + writeValveConfigurationAndControlInteractionInfo.put("writeOpenDurationAttribute", writeValveConfigurationAndControlOpenDurationAttributeInteractionInfo); + Map writeValveConfigurationAndControlStartUpStateCommandParams = new LinkedHashMap(); + CommandParameterInfo valveConfigurationAndControlstartUpStateCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeValveConfigurationAndControlStartUpStateCommandParams.put( + "value", + valveConfigurationAndControlstartUpStateCommandParameterInfo + ); + InteractionInfo writeValveConfigurationAndControlStartUpStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).writeStartUpStateAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeValveConfigurationAndControlStartUpStateCommandParams + ); + writeValveConfigurationAndControlInteractionInfo.put("writeStartUpStateAttribute", writeValveConfigurationAndControlStartUpStateAttributeInteractionInfo); + Map writeValveConfigurationAndControlOpenLevelCommandParams = new LinkedHashMap(); + CommandParameterInfo valveConfigurationAndControlopenLevelCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeValveConfigurationAndControlOpenLevelCommandParams.put( + "value", + valveConfigurationAndControlopenLevelCommandParameterInfo + ); + InteractionInfo writeValveConfigurationAndControlOpenLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ValveConfigurationAndControlCluster) cluster).writeOpenLevelAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeValveConfigurationAndControlOpenLevelCommandParams + ); + writeValveConfigurationAndControlInteractionInfo.put("writeOpenLevelAttribute", writeValveConfigurationAndControlOpenLevelAttributeInteractionInfo); + writeAttributeMap.put("valveConfigurationAndControl", writeValveConfigurationAndControlInteractionInfo); Map writeDemandResponseLoadControlInteractionInfo = new LinkedHashMap<>(); Map writeDemandResponseLoadControlDefaultRandomStartCommandParams = new LinkedHashMap(); CommandParameterInfo demandResponseLoadControldefaultRandomStartCommandParameterInfo = diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt new file mode 100644 index 00000000000000..c51a8e06724875 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import java.util.Optional +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class BooleanSensorConfigurationClusterAlarmsStateChangedEvent( + val alarmsActive: UInt, + val alarmsSuppressed: Optional +) { + override fun toString(): String = buildString { + append("BooleanSensorConfigurationClusterAlarmsStateChangedEvent {\n") + append("\talarmsActive : $alarmsActive\n") + append("\talarmsSuppressed : $alarmsSuppressed\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_ALARMS_ACTIVE), alarmsActive) + if (alarmsSuppressed.isPresent) { + val optalarmsSuppressed = alarmsSuppressed.get() + put(ContextSpecificTag(TAG_ALARMS_SUPPRESSED), optalarmsSuppressed) + } + endStructure() + } + } + + companion object { + private const val TAG_ALARMS_ACTIVE = 0 + private const val TAG_ALARMS_SUPPRESSED = 1 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): BooleanSensorConfigurationClusterAlarmsStateChangedEvent { + tlvReader.enterStructure(tlvTag) + val alarmsActive = tlvReader.getUInt(ContextSpecificTag(TAG_ALARMS_ACTIVE)) + val alarmsSuppressed = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_ALARMS_SUPPRESSED))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_ALARMS_SUPPRESSED))) + } else { + Optional.empty() + } + + tlvReader.exitContainer() + + return BooleanSensorConfigurationClusterAlarmsStateChangedEvent( + alarmsActive, + alarmsSuppressed + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt new file mode 100644 index 00000000000000..cb432d975e1275 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt @@ -0,0 +1,55 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ValveConfigurationAndControlClusterValveFaultEvent(val valveFault: UInt) { + override fun toString(): String = buildString { + append("ValveConfigurationAndControlClusterValveFaultEvent {\n") + append("\tvalveFault : $valveFault\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_VALVE_FAULT), valveFault) + endStructure() + } + } + + companion object { + private const val TAG_VALVE_FAULT = 0 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ValveConfigurationAndControlClusterValveFaultEvent { + tlvReader.enterStructure(tlvTag) + val valveFault = tlvReader.getUInt(ContextSpecificTag(TAG_VALVE_FAULT)) + + tlvReader.exitContainer() + + return ValveConfigurationAndControlClusterValveFaultEvent(valveFault) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt new file mode 100644 index 00000000000000..d015f73b2e61b5 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt @@ -0,0 +1,55 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ValveConfigurationAndControlClusterValveStateChangedEvent(val valveState: UInt) { + override fun toString(): String = buildString { + append("ValveConfigurationAndControlClusterValveStateChangedEvent {\n") + append("\tvalveState : $valveState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_VALVE_STATE), valveState) + endStructure() + } + } + + companion object { + private const val TAG_VALVE_STATE = 0 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ValveConfigurationAndControlClusterValveStateChangedEvent { + tlvReader.enterStructure(tlvTag) + val valveState = tlvReader.getUInt(ContextSpecificTag(TAG_VALVE_STATE)) + + tlvReader.exitContainer() + + return ValveConfigurationAndControlClusterValveStateChangedEvent(valveState) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni index aaf9b5a5d48257..ab6a73b670b4ad 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni @@ -103,6 +103,7 @@ eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BasicInformationClusterLeaveEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BasicInformationClusterReachableChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BasicInformationClusterStartUpEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BooleanStateClusterStateChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BridgedDeviceBasicInformationClusterReachableChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/BridgedDeviceBasicInformationClusterStartUpEvent.kt", @@ -147,6 +148,8 @@ eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/TimeSynchronizationClusterTimeZoneStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/UnitTestingClusterTestEventEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/UnitTestingClusterTestFabricScopedEventEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/WiFiNetworkDiagnosticsClusterAssociationFailureEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/WiFiNetworkDiagnosticsClusterConnectionStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/WiFiNetworkDiagnosticsClusterDisconnectionEvent.kt", diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BooleanSensorConfigurationCluster.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BooleanSensorConfigurationCluster.kt new file mode 100644 index 00000000000000..068aa709815206 --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BooleanSensorConfigurationCluster.kt @@ -0,0 +1,153 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package matter.devicecontroller.cluster.clusters + +import matter.controller.MatterController +import matter.devicecontroller.cluster.structs.* + +class BooleanSensorConfigurationCluster( + private val controller: MatterController, + private val endpointId: UShort +) { + class GeneratedCommandListAttribute(val value: List) + + class AcceptedCommandListAttribute(val value: List) + + class EventListAttribute(val value: List) + + class AttributeListAttribute(val value: List) + + suspend fun suppressRequest(alarmsToSuppress: UInt, timedInvokeTimeoutMs: Int? = null) { + val commandId = 0L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun readSensitivityLevelAttribute(): UByte { + // Implementation needs to be added here + } + + suspend fun writeSensitivityLevelAttribute(value: UInt, timedWriteTimeoutMs: Int? = null) { + if (timedWriteTimeoutMs != null) { + // Do the action with timedWriteTimeoutMs + } else { + // Do the action without timedWriteTimeoutMs + } + } + + suspend fun subscribeSensitivityLevelAttribute(minInterval: Int, maxInterval: Int): UByte { + // Implementation needs to be added here + } + + suspend fun readAlarmsActiveAttribute(): UByte { + // Implementation needs to be added here + } + + suspend fun subscribeAlarmsActiveAttribute(minInterval: Int, maxInterval: Int): UByte { + // Implementation needs to be added here + } + + suspend fun readAlarmsSuppressedAttribute(): UByte { + // Implementation needs to be added here + } + + suspend fun subscribeAlarmsSuppressedAttribute(minInterval: Int, maxInterval: Int): UByte { + // Implementation needs to be added here + } + + suspend fun readAlarmsEnabledAttribute(): UByte { + // Implementation needs to be added here + } + + suspend fun writeAlarmsEnabledAttribute(value: UInt, timedWriteTimeoutMs: Int? = null) { + if (timedWriteTimeoutMs != null) { + // Do the action with timedWriteTimeoutMs + } else { + // Do the action without timedWriteTimeoutMs + } + } + + suspend fun subscribeAlarmsEnabledAttribute(minInterval: Int, maxInterval: Int): UByte { + // Implementation needs to be added here + } + + suspend fun readGeneratedCommandListAttribute(): GeneratedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeGeneratedCommandListAttribute( + minInterval: Int, + maxInterval: Int + ): GeneratedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun readAcceptedCommandListAttribute(): AcceptedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeAcceptedCommandListAttribute( + minInterval: Int, + maxInterval: Int + ): AcceptedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun readEventListAttribute(): EventListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeEventListAttribute(minInterval: Int, maxInterval: Int): EventListAttribute { + // Implementation needs to be added here + } + + suspend fun readAttributeListAttribute(): AttributeListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeAttributeListAttribute( + minInterval: Int, + maxInterval: Int + ): AttributeListAttribute { + // Implementation needs to be added here + } + + suspend fun readFeatureMapAttribute(): UInt { + // Implementation needs to be added here + } + + suspend fun subscribeFeatureMapAttribute(minInterval: Int, maxInterval: Int): UInt { + // Implementation needs to be added here + } + + suspend fun readClusterRevisionAttribute(): UShort { + // Implementation needs to be added here + } + + suspend fun subscribeClusterRevisionAttribute(minInterval: Int, maxInterval: Int): UShort { + // Implementation needs to be added here + } + + companion object { + const val CLUSTER_ID: UInt = 128u + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ValveConfigurationAndControlCluster.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ValveConfigurationAndControlCluster.kt new file mode 100644 index 00000000000000..bdcc7781467968 --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ValveConfigurationAndControlCluster.kt @@ -0,0 +1,266 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package matter.devicecontroller.cluster.clusters + +import matter.controller.MatterController +import matter.devicecontroller.cluster.structs.* + +class ValveConfigurationAndControlCluster( + private val controller: MatterController, + private val endpointId: UShort +) { + class OpenDurationAttribute(val value: UInt?) + + class AutoCloseTimeAttribute(val value: ULong?) + + class RemainingDurationAttribute(val value: UInt?) + + class CurrentStateAttribute(val value: UInt?) + + class TargetStateAttribute(val value: UInt?) + + class CurrentLevelAttribute(val value: UByte?) + + class TargetLevelAttribute(val value: UByte?) + + class OpenLevelAttribute(val value: UByte?) + + class GeneratedCommandListAttribute(val value: List) + + class AcceptedCommandListAttribute(val value: List) + + class EventListAttribute(val value: List) + + class AttributeListAttribute(val value: List) + + suspend fun open(openDuration: UInt?, timedInvokeTimeoutMs: Int? = null) { + val commandId = 0L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun close(timedInvokeTimeoutMs: Int? = null) { + val commandId = 1L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun setLevel(level: UByte, openDuration: UInt?, timedInvokeTimeoutMs: Int? = null) { + val commandId = 2L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun readOpenDurationAttribute(): OpenDurationAttribute { + // Implementation needs to be added here + } + + suspend fun writeOpenDurationAttribute(value: UInt, timedWriteTimeoutMs: Int? = null) { + if (timedWriteTimeoutMs != null) { + // Do the action with timedWriteTimeoutMs + } else { + // Do the action without timedWriteTimeoutMs + } + } + + suspend fun subscribeOpenDurationAttribute( + minInterval: Int, + maxInterval: Int + ): OpenDurationAttribute { + // Implementation needs to be added here + } + + suspend fun readAutoCloseTimeAttribute(): AutoCloseTimeAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeAutoCloseTimeAttribute( + minInterval: Int, + maxInterval: Int + ): AutoCloseTimeAttribute { + // Implementation needs to be added here + } + + suspend fun readRemainingDurationAttribute(): RemainingDurationAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeRemainingDurationAttribute( + minInterval: Int, + maxInterval: Int + ): RemainingDurationAttribute { + // Implementation needs to be added here + } + + suspend fun readCurrentStateAttribute(): CurrentStateAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeCurrentStateAttribute( + minInterval: Int, + maxInterval: Int + ): CurrentStateAttribute { + // Implementation needs to be added here + } + + suspend fun readTargetStateAttribute(): TargetStateAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeTargetStateAttribute( + minInterval: Int, + maxInterval: Int + ): TargetStateAttribute { + // Implementation needs to be added here + } + + suspend fun readStartUpStateAttribute(): UByte { + // Implementation needs to be added here + } + + suspend fun writeStartUpStateAttribute(value: UInt, timedWriteTimeoutMs: Int? = null) { + if (timedWriteTimeoutMs != null) { + // Do the action with timedWriteTimeoutMs + } else { + // Do the action without timedWriteTimeoutMs + } + } + + suspend fun subscribeStartUpStateAttribute(minInterval: Int, maxInterval: Int): UByte { + // Implementation needs to be added here + } + + suspend fun readCurrentLevelAttribute(): CurrentLevelAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeCurrentLevelAttribute( + minInterval: Int, + maxInterval: Int + ): CurrentLevelAttribute { + // Implementation needs to be added here + } + + suspend fun readTargetLevelAttribute(): TargetLevelAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeTargetLevelAttribute( + minInterval: Int, + maxInterval: Int + ): TargetLevelAttribute { + // Implementation needs to be added here + } + + suspend fun readOpenLevelAttribute(): OpenLevelAttribute { + // Implementation needs to be added here + } + + suspend fun writeOpenLevelAttribute(value: UByte, timedWriteTimeoutMs: Int? = null) { + if (timedWriteTimeoutMs != null) { + // Do the action with timedWriteTimeoutMs + } else { + // Do the action without timedWriteTimeoutMs + } + } + + suspend fun subscribeOpenLevelAttribute(minInterval: Int, maxInterval: Int): OpenLevelAttribute { + // Implementation needs to be added here + } + + suspend fun readValveFaultAttribute(): UShort { + // Implementation needs to be added here + } + + suspend fun subscribeValveFaultAttribute(minInterval: Int, maxInterval: Int): UShort { + // Implementation needs to be added here + } + + suspend fun readGeneratedCommandListAttribute(): GeneratedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeGeneratedCommandListAttribute( + minInterval: Int, + maxInterval: Int + ): GeneratedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun readAcceptedCommandListAttribute(): AcceptedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeAcceptedCommandListAttribute( + minInterval: Int, + maxInterval: Int + ): AcceptedCommandListAttribute { + // Implementation needs to be added here + } + + suspend fun readEventListAttribute(): EventListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeEventListAttribute(minInterval: Int, maxInterval: Int): EventListAttribute { + // Implementation needs to be added here + } + + suspend fun readAttributeListAttribute(): AttributeListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeAttributeListAttribute( + minInterval: Int, + maxInterval: Int + ): AttributeListAttribute { + // Implementation needs to be added here + } + + suspend fun readFeatureMapAttribute(): UInt { + // Implementation needs to be added here + } + + suspend fun subscribeFeatureMapAttribute(minInterval: Int, maxInterval: Int): UInt { + // Implementation needs to be added here + } + + suspend fun readClusterRevisionAttribute(): UShort { + // Implementation needs to be added here + } + + suspend fun subscribeClusterRevisionAttribute(minInterval: Int, maxInterval: Int): UShort { + // Implementation needs to be added here + } + + companion object { + const val CLUSTER_ID: UInt = 129u + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt new file mode 100644 index 00000000000000..bf64761f255688 --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.devicecontroller.cluster.eventstructs + +import java.util.Optional +import matter.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class BooleanSensorConfigurationClusterAlarmsStateChangedEvent( + val alarmsActive: UInt, + val alarmsSuppressed: Optional +) { + override fun toString(): String = buildString { + append("BooleanSensorConfigurationClusterAlarmsStateChangedEvent {\n") + append("\talarmsActive : $alarmsActive\n") + append("\talarmsSuppressed : $alarmsSuppressed\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_ALARMS_ACTIVE), alarmsActive) + if (alarmsSuppressed.isPresent) { + val optalarmsSuppressed = alarmsSuppressed.get() + put(ContextSpecificTag(TAG_ALARMS_SUPPRESSED), optalarmsSuppressed) + } + endStructure() + } + } + + companion object { + private const val TAG_ALARMS_ACTIVE = 0 + private const val TAG_ALARMS_SUPPRESSED = 1 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): BooleanSensorConfigurationClusterAlarmsStateChangedEvent { + tlvReader.enterStructure(tlvTag) + val alarmsActive = tlvReader.getUInt(ContextSpecificTag(TAG_ALARMS_ACTIVE)) + val alarmsSuppressed = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_ALARMS_SUPPRESSED))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_ALARMS_SUPPRESSED))) + } else { + Optional.empty() + } + + tlvReader.exitContainer() + + return BooleanSensorConfigurationClusterAlarmsStateChangedEvent( + alarmsActive, + alarmsSuppressed + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt new file mode 100644 index 00000000000000..6aa0f2c8ea44bf --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt @@ -0,0 +1,55 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.devicecontroller.cluster.eventstructs + +import matter.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ValveConfigurationAndControlClusterValveFaultEvent(val valveFault: UInt) { + override fun toString(): String = buildString { + append("ValveConfigurationAndControlClusterValveFaultEvent {\n") + append("\tvalveFault : $valveFault\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_VALVE_FAULT), valveFault) + endStructure() + } + } + + companion object { + private const val TAG_VALVE_FAULT = 0 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ValveConfigurationAndControlClusterValveFaultEvent { + tlvReader.enterStructure(tlvTag) + val valveFault = tlvReader.getUInt(ContextSpecificTag(TAG_VALVE_FAULT)) + + tlvReader.exitContainer() + + return ValveConfigurationAndControlClusterValveFaultEvent(valveFault) + } + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt new file mode 100644 index 00000000000000..37e58c25cea495 --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt @@ -0,0 +1,55 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.devicecontroller.cluster.eventstructs + +import matter.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ValveConfigurationAndControlClusterValveStateChangedEvent(val valveState: UInt) { + override fun toString(): String = buildString { + append("ValveConfigurationAndControlClusterValveStateChangedEvent {\n") + append("\tvalveState : $valveState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_VALVE_STATE), valveState) + endStructure() + } + } + + companion object { + private const val TAG_VALVE_STATE = 0 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): ValveConfigurationAndControlClusterValveStateChangedEvent { + tlvReader.enterStructure(tlvTag) + val valveState = tlvReader.getUInt(ContextSpecificTag(TAG_VALVE_STATE)) + + tlvReader.exitContainer() + + return ValveConfigurationAndControlClusterValveStateChangedEvent(valveState) + } + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni index 54dbdd6875c852..3a27dbc0175593 100644 --- a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni @@ -103,6 +103,7 @@ matter_eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BasicInformationClusterLeaveEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BasicInformationClusterReachableChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BasicInformationClusterStartUpEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BooleanSensorConfigurationClusterAlarmsStateChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BooleanStateClusterStateChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BridgedDeviceBasicInformationClusterReachableChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/BridgedDeviceBasicInformationClusterStartUpEvent.kt", @@ -147,6 +148,8 @@ matter_eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/TimeSynchronizationClusterTimeZoneStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/UnitTestingClusterTestEventEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/UnitTestingClusterTestFabricScopedEventEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveFaultEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ValveConfigurationAndControlClusterValveStateChangedEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/WiFiNetworkDiagnosticsClusterAssociationFailureEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/WiFiNetworkDiagnosticsClusterConnectionStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/WiFiNetworkDiagnosticsClusterDisconnectionEvent.kt", @@ -167,6 +170,7 @@ matter_clusters_sources = [ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BasicInformationCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BinaryInputBasicCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BindingCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BooleanSensorConfigurationCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BooleanStateCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BridgedDeviceBasicInformationCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/CarbonDioxideConcentrationMeasurementCluster.kt", @@ -252,6 +256,7 @@ matter_clusters_sources = [ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/UnitLocalizationCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/UnitTestingCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/UserLabelCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ValveConfigurationAndControlCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/WakeOnLanCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/WiFiNetworkDiagnosticsCluster.kt", "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/WindowCoveringCluster.kt", diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp index 2d8fe197e143f4..f39397789454f8 100644 --- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp @@ -17831,6 +17831,570 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR } break; } + case app::Clusters::BooleanSensorConfiguration::Id: { + using namespace app::Clusters::BooleanSensorConfiguration; + switch (aPath.mAttributeId) + { + case Attributes::SensitivityLevel::Id: { + using TypeInfo = Attributes::SensitivityLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::AlarmsActive::Id: { + using TypeInfo = Attributes::AlarmsActive::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::AlarmsSuppressed::Id: { + using TypeInfo = Attributes::AlarmsSuppressed::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::AlarmsEnabled::Id: { + using TypeInfo = Attributes::AlarmsEnabled::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::GeneratedCommandList::Id: { + using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AcceptedCommandList::Id: { + using TypeInfo = Attributes::AcceptedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::EventList::Id: { + using TypeInfo = Attributes::EventList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AttributeList::Id: { + using TypeInfo = Attributes::AttributeList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::FeatureMap::Id: { + using TypeInfo = Attributes::FeatureMap::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + return value; + } + case Attributes::ClusterRevision::Id: { + using TypeInfo = Attributes::ClusterRevision::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + break; + } + break; + } + case app::Clusters::ValveConfigurationAndControl::Id: { + using namespace app::Clusters::ValveConfigurationAndControl; + switch (aPath.mAttributeId) + { + case Attributes::OpenDuration::Id: { + using TypeInfo = Attributes::OpenDuration::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::AutoCloseTime::Id: { + using TypeInfo = Attributes::AutoCloseTime::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::RemainingDuration::Id: { + using TypeInfo = Attributes::RemainingDuration::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::CurrentState::Id: { + using TypeInfo = Attributes::CurrentState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::TargetState::Id: { + using TypeInfo = Attributes::TargetState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::StartUpState::Id: { + using TypeInfo = Attributes::StartUpState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::CurrentLevel::Id: { + using TypeInfo = Attributes::CurrentLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::TargetLevel::Id: { + using TypeInfo = Attributes::TargetLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::OpenLevel::Id: { + using TypeInfo = Attributes::OpenLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + if (cppValue.IsNull()) + { + value = nullptr; + } + else + { + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + } + return value; + } + case Attributes::ValveFault::Id: { + using TypeInfo = Attributes::ValveFault::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + case Attributes::GeneratedCommandList::Id: { + using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AcceptedCommandList::Id: { + using TypeInfo = Attributes::AcceptedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::EventList::Id: { + using TypeInfo = Attributes::EventList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::AttributeList::Id: { + using TypeInfo = Attributes::AttributeList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + chip::JniReferences::GetInstance().CreateArrayList(value); + + auto iter_value_0 = cppValue.begin(); + while (iter_value_0.Next()) + { + auto & entry_0 = iter_value_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(value, newElement_0); + } + return value; + } + case Attributes::FeatureMap::Id: { + using TypeInfo = Attributes::FeatureMap::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Long"; + std::string valueCtorSignature = "(J)V"; + jlong jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), + jnivalue, value); + return value; + } + case Attributes::ClusterRevision::Id: { + using TypeInfo = Attributes::ClusterRevision::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value; + std::string valueClassName = "java/lang/Integer"; + std::string valueCtorSignature = "(I)V"; + jint jnivalue = static_cast(cppValue); + chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue, + value); + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + break; + } + break; + } case app::Clusters::DemandResponseLoadControl::Id: { using namespace app::Clusters::DemandResponseLoadControl; switch (aPath.mAttributeId) diff --git a/src/controller/java/zap-generated/CHIPClientCallbacks.h b/src/controller/java/zap-generated/CHIPClientCallbacks.h index 2c4046a73920c0..18294e94a57073 100644 --- a/src/controller/java/zap-generated/CHIPClientCallbacks.h +++ b/src/controller/java/zap-generated/CHIPClientCallbacks.h @@ -675,6 +675,22 @@ typedef void (*ActivatedCarbonFilterMonitoringEventListListAttributeCallback)( void * context, const chip::app::DataModel::DecodableList & data); typedef void (*ActivatedCarbonFilterMonitoringAttributeListListAttributeCallback)( void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanSensorConfigurationGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanSensorConfigurationAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanSensorConfigurationEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*BooleanSensorConfigurationAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ValveConfigurationAndControlGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ValveConfigurationAndControlAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ValveConfigurationAndControlEventListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*ValveConfigurationAndControlAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); typedef void (*DemandResponseLoadControlLoadControlProgramsListAttributeCallback)( void * context, const chip::app::DataModel::DecodableList< diff --git a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp index 9d3dbec50b8c25..77c56f69bd72ca 100644 --- a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp @@ -3108,6 +3108,282 @@ JNI_METHOD(void, ActivatedCarbonFilterMonitoringCluster, writeLastChangedTimeAtt onFailure.release(); } +JNI_METHOD(void, BooleanSensorConfigurationCluster, writeSensitivityLevelAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::BooleanSensorConfiguration::Attributes::SensitivityLevel::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + cppValue = + static_cast>(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + BooleanSensorConfigurationCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, BooleanSensorConfigurationCluster, writeAlarmsEnabledAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsEnabled::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + cppValue.SetRaw(static_cast::IntegerType>( + chip::JniReferences::GetInstance().IntegerToPrimitive(value))); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + BooleanSensorConfigurationCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, ValveConfigurationAndControlCluster, writeOpenDurationAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + if (value == nullptr) + { + cppValue.SetNull(); + } + else + { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = static_cast>( + chip::JniReferences::GetInstance().LongToPrimitive(value)); + } + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + ValveConfigurationAndControlCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, ValveConfigurationAndControlCluster, writeStartUpStateAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::ValveConfigurationAndControl::Attributes::StartUpState::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + cppValue = + static_cast>(chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + ValveConfigurationAndControlCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, ValveConfigurationAndControlCluster, writeOpenLevelAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenLevel::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + if (value == nullptr) + { + cppValue.SetNull(); + } + else + { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = static_cast>( + chip::JniReferences::GetInstance().IntegerToPrimitive(value)); + } + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + ValveConfigurationAndControlCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, DemandResponseLoadControlCluster, writeDefaultRandomStartAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) { diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index f00d93faa06214..feee60c307d36d 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -3457,6 +3457,180 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } break; } + case app::Clusters::BooleanSensorConfiguration::Id: { + using namespace app::Clusters::BooleanSensorConfiguration; + switch (aPath.mEventId) + { + case Events::AlarmsStateChanged::Id: { + Events::AlarmsStateChanged::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_alarmsActive; + std::string value_alarmsActiveClassName = "java/lang/Integer"; + std::string value_alarmsActiveCtorSignature = "(I)V"; + jint jnivalue_alarmsActive = static_cast(cppValue.alarmsActive.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_alarmsActiveClassName.c_str(), + value_alarmsActiveCtorSignature.c_str(), + jnivalue_alarmsActive, value_alarmsActive); + + jobject value_alarmsSuppressed; + if (!cppValue.alarmsSuppressed.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, value_alarmsSuppressed); + } + else + { + jobject value_alarmsSuppressedInsideOptional; + std::string value_alarmsSuppressedInsideOptionalClassName = "java/lang/Integer"; + std::string value_alarmsSuppressedInsideOptionalCtorSignature = "(I)V"; + jint jnivalue_alarmsSuppressedInsideOptional = static_cast(cppValue.alarmsSuppressed.Value().Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_alarmsSuppressedInsideOptionalClassName.c_str(), + value_alarmsSuppressedInsideOptionalCtorSignature.c_str(), jnivalue_alarmsSuppressedInsideOptional, + value_alarmsSuppressedInsideOptional); + chip::JniReferences::GetInstance().CreateOptional(value_alarmsSuppressedInsideOptional, value_alarmsSuppressed); + } + + jclass alarmsStateChangedStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$BooleanSensorConfigurationClusterAlarmsStateChangedEvent", + alarmsStateChangedStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$BooleanSensorConfigurationClusterAlarmsStateChangedEvent"); + return nullptr; + } + jmethodID alarmsStateChangedStructCtor = + env->GetMethodID(alarmsStateChangedStructClass, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V"); + if (alarmsStateChangedStructCtor == nullptr) + { + ChipLogError( + Zcl, "Could not find ChipEventStructs$BooleanSensorConfigurationClusterAlarmsStateChangedEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(alarmsStateChangedStructClass, alarmsStateChangedStructCtor, value_alarmsActive, + value_alarmsSuppressed); + + return value; + } + case Events::SensorFault::Id: { + Events::SensorFault::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jclass sensorFaultStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$BooleanSensorConfigurationClusterSensorFaultEvent", + sensorFaultStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$BooleanSensorConfigurationClusterSensorFaultEvent"); + return nullptr; + } + jmethodID sensorFaultStructCtor = env->GetMethodID(sensorFaultStructClass, "", "()V"); + if (sensorFaultStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$BooleanSensorConfigurationClusterSensorFaultEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(sensorFaultStructClass, sensorFaultStructCtor); + + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + break; + } + break; + } + case app::Clusters::ValveConfigurationAndControl::Id: { + using namespace app::Clusters::ValveConfigurationAndControl; + switch (aPath.mEventId) + { + case Events::ValveStateChanged::Id: { + Events::ValveStateChanged::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_valveState; + std::string value_valveStateClassName = "java/lang/Integer"; + std::string value_valveStateCtorSignature = "(I)V"; + jint jnivalue_valveState = static_cast(cppValue.valveState); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_valveStateClassName.c_str(), value_valveStateCtorSignature.c_str(), jnivalue_valveState, value_valveState); + + jclass valveStateChangedStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$ValveConfigurationAndControlClusterValveStateChangedEvent", + valveStateChangedStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, + "Could not find class ChipEventStructs$ValveConfigurationAndControlClusterValveStateChangedEvent"); + return nullptr; + } + jmethodID valveStateChangedStructCtor = + env->GetMethodID(valveStateChangedStructClass, "", "(Ljava/lang/Integer;)V"); + if (valveStateChangedStructCtor == nullptr) + { + ChipLogError( + Zcl, "Could not find ChipEventStructs$ValveConfigurationAndControlClusterValveStateChangedEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(valveStateChangedStructClass, valveStateChangedStructCtor, value_valveState); + + return value; + } + case Events::ValveFault::Id: { + Events::ValveFault::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_valveFault; + std::string value_valveFaultClassName = "java/lang/Integer"; + std::string value_valveFaultCtorSignature = "(I)V"; + jint jnivalue_valveFault = static_cast(cppValue.valveFault.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_valveFaultClassName.c_str(), value_valveFaultCtorSignature.c_str(), jnivalue_valveFault, value_valveFault); + + jclass valveFaultStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$ValveConfigurationAndControlClusterValveFaultEvent", + valveFaultStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ValveConfigurationAndControlClusterValveFaultEvent"); + return nullptr; + } + jmethodID valveFaultStructCtor = env->GetMethodID(valveFaultStructClass, "", "(Ljava/lang/Integer;)V"); + if (valveFaultStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ValveConfigurationAndControlClusterValveFaultEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(valveFaultStructClass, valveFaultStructCtor, value_valveFault); + + return value; + } + default: + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + break; + } + break; + } case app::Clusters::DemandResponseLoadControl::Id: { using namespace app::Clusters::DemandResponseLoadControl; switch (aPath.mEventId) diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index a432363b6915a8..d1303b030bd0dd 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -27999,6 +27999,1131 @@ void CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::Callback env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPBooleanSensorConfigurationGeneratedCommandListAttributeCallback:: +CHIPBooleanSensorConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPBooleanSensorConfigurationGeneratedCommandListAttributeCallback::~ +CHIPBooleanSensorConfigurationGeneratedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPBooleanSensorConfigurationGeneratedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPBooleanSensorConfigurationAcceptedCommandListAttributeCallback:: +CHIPBooleanSensorConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPBooleanSensorConfigurationAcceptedCommandListAttributeCallback::~ +CHIPBooleanSensorConfigurationAcceptedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPBooleanSensorConfigurationAcceptedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPBooleanSensorConfigurationEventListAttributeCallback::CHIPBooleanSensorConfigurationEventListAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPBooleanSensorConfigurationEventListAttributeCallback::~CHIPBooleanSensorConfigurationEventListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPBooleanSensorConfigurationEventListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPBooleanSensorConfigurationAttributeListAttributeCallback::CHIPBooleanSensorConfigurationAttributeListAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPBooleanSensorConfigurationAttributeListAttributeCallback::~CHIPBooleanSensorConfigurationAttributeListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPBooleanSensorConfigurationAttributeListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPValveConfigurationAndControlOpenDurationAttributeCallback::CHIPValveConfigurationAndControlOpenDurationAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlOpenDurationAttributeCallback::~CHIPValveConfigurationAndControlOpenDurationAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlOpenDurationAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + jlong jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback::CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback::~CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + jlong jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback:: +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback::~ +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlRemainingDurationAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Long;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Long"; + std::string javaValueCtorSignature = "(J)V"; + jlong jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlCurrentStateAttributeCallback::CHIPValveConfigurationAndControlCurrentStateAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlCurrentStateAttributeCallback::~CHIPValveConfigurationAndControlCurrentStateAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlCurrentStateAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + jint jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlTargetStateAttributeCallback::CHIPValveConfigurationAndControlTargetStateAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlTargetStateAttributeCallback::~CHIPValveConfigurationAndControlTargetStateAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlTargetStateAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + jint jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlCurrentLevelAttributeCallback::CHIPValveConfigurationAndControlCurrentLevelAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlCurrentLevelAttributeCallback::~CHIPValveConfigurationAndControlCurrentLevelAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlCurrentLevelAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + jint jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlTargetLevelAttributeCallback::CHIPValveConfigurationAndControlTargetLevelAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlTargetLevelAttributeCallback::~CHIPValveConfigurationAndControlTargetLevelAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlTargetLevelAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + jint jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlOpenLevelAttributeCallback::CHIPValveConfigurationAndControlOpenLevelAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlOpenLevelAttributeCallback::~CHIPValveConfigurationAndControlOpenLevelAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlOpenLevelAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + if (value.IsNull()) + { + javaValue = nullptr; + } + else + { + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + jint jnijavaValue = static_cast(value.Value()); + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + jnijavaValue, javaValue); + } + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback:: +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback::~ +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback:: +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback::~ +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPValveConfigurationAndControlEventListAttributeCallback::CHIPValveConfigurationAndControlEventListAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlEventListAttributeCallback::~CHIPValveConfigurationAndControlEventListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlEventListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPValveConfigurationAndControlAttributeListAttributeCallback::CHIPValveConfigurationAndControlAttributeListAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPValveConfigurationAndControlAttributeListAttributeCallback::~CHIPValveConfigurationAndControlAttributeListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPValveConfigurationAndControlAttributeListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject arrayListObj; + chip::JniReferences::GetInstance().CreateArrayList(arrayListObj); + + auto iter_arrayListObj_0 = list.begin(); + while (iter_arrayListObj_0.Next()) + { + auto & entry_0 = iter_arrayListObj_0.GetValue(); + jobject newElement_0; + std::string newElement_0ClassName = "java/lang/Long"; + std::string newElement_0CtorSignature = "(J)V"; + jlong jninewElement_0 = static_cast(entry_0); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback:: CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java new file mode 100644 index 00000000000000..99db5abbfecc9f --- /dev/null +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -0,0 +1,40492 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// THIS FILE IS GENERATED BY ZAP +package chip.devicecontroller; + +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +public class ChipClusters { + + public interface DefaultClusterCallback { + void onSuccess(); + void onError(Exception error); + } + + public interface CharStringAttributeCallback { + /** Indicates a successful read for a CHAR_STRING attribute. */ + void onSuccess(String value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface OctetStringAttributeCallback { + /** Indicates a successful read for an OCTET_STRING attribute. */ + void onSuccess(byte[] value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface IntegerAttributeCallback { + void onSuccess(int value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface LongAttributeCallback { + void onSuccess(long value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface BooleanAttributeCallback { + void onSuccess(boolean value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface FloatAttributeCallback { + void onSuccess(float value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public interface DoubleAttributeCallback { + void onSuccess(double value); + void onError(Exception error); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public static abstract class BaseChipCluster { + protected long chipClusterPtr; + + public BaseChipCluster(long devicePtr, int endpointId) { + chipClusterPtr = initWithDevice(devicePtr, endpointId); + } + + /** + * Sets the timeout, in milliseconds, after which commands sent through this cluster will fail + * with a timeout (regardless of whether or not a response has been received). If set to an + * empty optional, the default timeout will be used. + */ + public void setCommandTimeout(Optional timeoutMillis) { + setCommandTimeout(chipClusterPtr, timeoutMillis); + } + + private native void setCommandTimeout(long clusterPtr, Optional timeoutMillis); + + /** Returns the current timeout (in milliseconds) for commands sent through this cluster. */ + public Optional getCommandTimeout() { + Optional timeout = getCommandTimeout(chipClusterPtr); + return timeout == null ? Optional.empty() : timeout; + } + + private native Optional getCommandTimeout(long clusterPtr); + + public abstract long initWithDevice(long devicePtr, int endpointId); + + public native void deleteCluster(long chipClusterPtr); + + @SuppressWarnings("deprecation") + protected void finalize() throws Throwable { + super.finalize(); + + if (chipClusterPtr != 0) { + deleteCluster(chipClusterPtr); + chipClusterPtr = 0; + } + } + } + + public static class IdentifyCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000003L; + + public IdentifyCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void identify(DefaultClusterCallback callback + , Integer identifyTime) { + identify(chipClusterPtr, callback, identifyTime, null); + } + + public void identify(DefaultClusterCallback callback + , Integer identifyTime + , int timedInvokeTimeoutMs) { + identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs); + } + + public void triggerEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant) { + triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); + } + + public void triggerEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant + , int timedInvokeTimeoutMs) { + triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + } + private native void identify(long chipClusterPtr, DefaultClusterCallback Callback + , Integer identifyTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback + , Integer effectIdentifier, Integer effectVariant + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readIdentifyTimeAttribute( + IntegerAttributeCallback callback + ) { + readIdentifyTimeAttribute(chipClusterPtr, callback); + } + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeIdentifyTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readIdentifyTypeAttribute( + IntegerAttributeCallback callback + ) { + readIdentifyTypeAttribute(chipClusterPtr, callback); + } + public void subscribeIdentifyTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readIdentifyTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeIdentifyTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeIdentifyTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readIdentifyTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeIdentifyTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class GroupsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000004L; + + public GroupsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void addGroup(AddGroupResponseCallback callback + , Integer groupID, String groupName) { + addGroup(chipClusterPtr, callback, groupID, groupName, null); + } + + public void addGroup(AddGroupResponseCallback callback + , Integer groupID, String groupName + , int timedInvokeTimeoutMs) { + addGroup(chipClusterPtr, callback, groupID, groupName, timedInvokeTimeoutMs); + } + + public void viewGroup(ViewGroupResponseCallback callback + , Integer groupID) { + viewGroup(chipClusterPtr, callback, groupID, null); + } + + public void viewGroup(ViewGroupResponseCallback callback + , Integer groupID + , int timedInvokeTimeoutMs) { + viewGroup(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs); + } + + public void getGroupMembership(GetGroupMembershipResponseCallback callback + , ArrayList groupList) { + getGroupMembership(chipClusterPtr, callback, groupList, null); + } + + public void getGroupMembership(GetGroupMembershipResponseCallback callback + , ArrayList groupList + , int timedInvokeTimeoutMs) { + getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs); + } + + public void removeGroup(RemoveGroupResponseCallback callback + , Integer groupID) { + removeGroup(chipClusterPtr, callback, groupID, null); + } + + public void removeGroup(RemoveGroupResponseCallback callback + , Integer groupID + , int timedInvokeTimeoutMs) { + removeGroup(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs); + } + + public void removeAllGroups(DefaultClusterCallback callback + ) { + removeAllGroups(chipClusterPtr, callback, null); + } + + public void removeAllGroups(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void addGroupIfIdentifying(DefaultClusterCallback callback + , Integer groupID, String groupName) { + addGroupIfIdentifying(chipClusterPtr, callback, groupID, groupName, null); + } + + public void addGroupIfIdentifying(DefaultClusterCallback callback + , Integer groupID, String groupName + , int timedInvokeTimeoutMs) { + addGroupIfIdentifying(chipClusterPtr, callback, groupID, groupName, timedInvokeTimeoutMs); + } + private native void addGroup(long chipClusterPtr, AddGroupResponseCallback Callback + , Integer groupID, String groupName + , @Nullable Integer timedInvokeTimeoutMs); + private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Callback + , Integer groupID + , @Nullable Integer timedInvokeTimeoutMs); + private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback Callback + , ArrayList groupList + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback + , Integer groupID + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupID, String groupName + , @Nullable Integer timedInvokeTimeoutMs); + public interface AddGroupResponseCallback { + void onSuccess(Integer status, Integer groupID); + + void onError(Exception error); + } + + public interface ViewGroupResponseCallback { + void onSuccess(Integer status, Integer groupID, String groupName); + + void onError(Exception error); + } + + public interface GetGroupMembershipResponseCallback { + void onSuccess(@Nullable Integer capacity, ArrayList groupList); + + void onError(Exception error); + } + + public interface RemoveGroupResponseCallback { + void onSuccess(Integer status, Integer groupID); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readNameSupportAttribute( + IntegerAttributeCallback callback + ) { + readNameSupportAttribute(chipClusterPtr, callback); + } + public void subscribeNameSupportAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ScenesCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000005L; + + public ScenesCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void addScene(AddSceneResponseCallback callback + , Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { + addScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, null); + } + + public void addScene(AddSceneResponseCallback callback + , Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , int timedInvokeTimeoutMs) { + addScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); + } + + public void viewScene(ViewSceneResponseCallback callback + , Integer groupID, Integer sceneID) { + viewScene(chipClusterPtr, callback, groupID, sceneID, null); + } + + public void viewScene(ViewSceneResponseCallback callback + , Integer groupID, Integer sceneID + , int timedInvokeTimeoutMs) { + viewScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs); + } + + public void removeScene(RemoveSceneResponseCallback callback + , Integer groupID, Integer sceneID) { + removeScene(chipClusterPtr, callback, groupID, sceneID, null); + } + + public void removeScene(RemoveSceneResponseCallback callback + , Integer groupID, Integer sceneID + , int timedInvokeTimeoutMs) { + removeScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs); + } + + public void removeAllScenes(RemoveAllScenesResponseCallback callback + , Integer groupID) { + removeAllScenes(chipClusterPtr, callback, groupID, null); + } + + public void removeAllScenes(RemoveAllScenesResponseCallback callback + , Integer groupID + , int timedInvokeTimeoutMs) { + removeAllScenes(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs); + } + + public void storeScene(StoreSceneResponseCallback callback + , Integer groupID, Integer sceneID) { + storeScene(chipClusterPtr, callback, groupID, sceneID, null); + } + + public void storeScene(StoreSceneResponseCallback callback + , Integer groupID, Integer sceneID + , int timedInvokeTimeoutMs) { + storeScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs); + } + + public void recallScene(DefaultClusterCallback callback + , Integer groupID, Integer sceneID, @Nullable Optional transitionTime) { + recallScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, null); + } + + public void recallScene(DefaultClusterCallback callback + , Integer groupID, Integer sceneID, @Nullable Optional transitionTime + , int timedInvokeTimeoutMs) { + recallScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, timedInvokeTimeoutMs); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback + , Integer groupID) { + getSceneMembership(chipClusterPtr, callback, groupID, null); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback + , Integer groupID + , int timedInvokeTimeoutMs) { + getSceneMembership(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs); + } + + public void enhancedAddScene(EnhancedAddSceneResponseCallback callback + , Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { + enhancedAddScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, null); + } + + public void enhancedAddScene(EnhancedAddSceneResponseCallback callback + , Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , int timedInvokeTimeoutMs) { + enhancedAddScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); + } + + public void enhancedViewScene(EnhancedViewSceneResponseCallback callback + , Integer groupID, Integer sceneID) { + enhancedViewScene(chipClusterPtr, callback, groupID, sceneID, null); + } + + public void enhancedViewScene(EnhancedViewSceneResponseCallback callback + , Integer groupID, Integer sceneID + , int timedInvokeTimeoutMs) { + enhancedViewScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs); + } + + public void copyScene(CopySceneResponseCallback callback + , Integer mode, Integer groupIdentifierFrom, Integer sceneIdentifierFrom, Integer groupIdentifierTo, Integer sceneIdentifierTo) { + copyScene(chipClusterPtr, callback, mode, groupIdentifierFrom, sceneIdentifierFrom, groupIdentifierTo, sceneIdentifierTo, null); + } + + public void copyScene(CopySceneResponseCallback callback + , Integer mode, Integer groupIdentifierFrom, Integer sceneIdentifierFrom, Integer groupIdentifierTo, Integer sceneIdentifierTo + , int timedInvokeTimeoutMs) { + copyScene(chipClusterPtr, callback, mode, groupIdentifierFrom, sceneIdentifierFrom, groupIdentifierTo, sceneIdentifierTo, timedInvokeTimeoutMs); + } + private native void addScene(long chipClusterPtr, AddSceneResponseCallback Callback + , Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , @Nullable Integer timedInvokeTimeoutMs); + private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Callback + , Integer groupID, Integer sceneID + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback Callback + , Integer groupID, Integer sceneID + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback Callback + , Integer groupID + , @Nullable Integer timedInvokeTimeoutMs); + private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback Callback + , Integer groupID, Integer sceneID + , @Nullable Integer timedInvokeTimeoutMs); + private native void recallScene(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupID, Integer sceneID, @Nullable Optional transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback Callback + , Integer groupID + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedAddScene(long chipClusterPtr, EnhancedAddSceneResponseCallback Callback + , Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedViewScene(long chipClusterPtr, EnhancedViewSceneResponseCallback Callback + , Integer groupID, Integer sceneID + , @Nullable Integer timedInvokeTimeoutMs); + private native void copyScene(long chipClusterPtr, CopySceneResponseCallback Callback + , Integer mode, Integer groupIdentifierFrom, Integer sceneIdentifierFrom, Integer groupIdentifierTo, Integer sceneIdentifierTo + , @Nullable Integer timedInvokeTimeoutMs); + public interface AddSceneResponseCallback { + void onSuccess(Integer status, Integer groupID, Integer sceneID); + + void onError(Exception error); + } + + public interface ViewSceneResponseCallback { + void onSuccess(Integer status, Integer groupID, Integer sceneID, Optional transitionTime, Optional sceneName, Optional> extensionFieldSets); + + void onError(Exception error); + } + + public interface RemoveSceneResponseCallback { + void onSuccess(Integer status, Integer groupID, Integer sceneID); + + void onError(Exception error); + } + + public interface RemoveAllScenesResponseCallback { + void onSuccess(Integer status, Integer groupID); + + void onError(Exception error); + } + + public interface StoreSceneResponseCallback { + void onSuccess(Integer status, Integer groupID, Integer sceneID); + + void onError(Exception error); + } + + public interface GetSceneMembershipResponseCallback { + void onSuccess(Integer status, @Nullable Integer capacity, Integer groupID, Optional> sceneList); + + void onError(Exception error); + } + + public interface EnhancedAddSceneResponseCallback { + void onSuccess(Integer status, Integer groupID, Integer sceneID); + + void onError(Exception error); + } + + public interface EnhancedViewSceneResponseCallback { + void onSuccess(Integer status, Integer groupID, Integer sceneID, Optional transitionTime, Optional sceneName, Optional> extensionFieldSets); + + void onError(Exception error); + } + + public interface CopySceneResponseCallback { + void onSuccess(Integer status, Integer groupIdentifierFrom, Integer sceneIdentifierFrom); + + void onError(Exception error); + } + + + public interface LastConfiguredByAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSceneCountAttribute( + IntegerAttributeCallback callback + ) { + readSceneCountAttribute(chipClusterPtr, callback); + } + public void subscribeSceneCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentSceneAttribute( + IntegerAttributeCallback callback + ) { + readCurrentSceneAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentSceneAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentGroupAttribute( + IntegerAttributeCallback callback + ) { + readCurrentGroupAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentGroupAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSceneValidAttribute( + BooleanAttributeCallback callback + ) { + readSceneValidAttribute(chipClusterPtr, callback); + } + public void subscribeSceneValidAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNameSupportAttribute( + IntegerAttributeCallback callback + ) { + readNameSupportAttribute(chipClusterPtr, callback); + } + public void subscribeNameSupportAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLastConfiguredByAttribute( + LastConfiguredByAttributeCallback callback + ) { + readLastConfiguredByAttribute(chipClusterPtr, callback); + } + public void subscribeLastConfiguredByAttribute( + LastConfiguredByAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLastConfiguredByAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSceneTableSizeAttribute( + IntegerAttributeCallback callback + ) { + readSceneTableSizeAttribute(chipClusterPtr, callback); + } + public void subscribeSceneTableSizeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSceneTableSizeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRemainingCapacityAttribute( + IntegerAttributeCallback callback + ) { + readRemainingCapacityAttribute(chipClusterPtr, callback); + } + public void subscribeRemainingCapacityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRemainingCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSceneCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSceneCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentSceneAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentSceneAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentGroupAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentGroupAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSceneValidAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeSceneValidAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastConfiguredByAttribute(long chipClusterPtr, + LastConfiguredByAttributeCallback callback + ); + private native void subscribeLastConfiguredByAttribute(long chipClusterPtr, + LastConfiguredByAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSceneTableSizeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSceneTableSizeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemainingCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OnOffCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000006L; + + public OnOffCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void off(DefaultClusterCallback callback + ) { + off(chipClusterPtr, callback, null); + } + + public void off(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + off(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void on(DefaultClusterCallback callback + ) { + on(chipClusterPtr, callback, null); + } + + public void on(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + on(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void toggle(DefaultClusterCallback callback + ) { + toggle(chipClusterPtr, callback, null); + } + + public void toggle(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void offWithEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant) { + offWithEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); + } + + public void offWithEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant + , int timedInvokeTimeoutMs) { + offWithEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + } + + public void onWithRecallGlobalScene(DefaultClusterCallback callback + ) { + onWithRecallGlobalScene(chipClusterPtr, callback, null); + } + + public void onWithRecallGlobalScene(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void onWithTimedOff(DefaultClusterCallback callback + , Integer onOffControl, Integer onTime, Integer offWaitTime) { + onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null); + } + + public void onWithTimedOff(DefaultClusterCallback callback + , Integer onOffControl, Integer onTime, Integer offWaitTime + , int timedInvokeTimeoutMs) { + onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); + } + private native void off(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void on(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback + , Integer effectIdentifier, Integer effectVariant + , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer onOffControl, Integer onTime, Integer offWaitTime + , @Nullable Integer timedInvokeTimeoutMs); + + public interface StartUpOnOffAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readOnOffAttribute( + BooleanAttributeCallback callback + ) { + readOnOffAttribute(chipClusterPtr, callback); + } + public void subscribeOnOffAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGlobalSceneControlAttribute( + BooleanAttributeCallback callback + ) { + readGlobalSceneControlAttribute(chipClusterPtr, callback); + } + public void subscribeGlobalSceneControlAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnTimeAttribute( + IntegerAttributeCallback callback + ) { + readOnTimeAttribute(chipClusterPtr, callback); + } + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOffWaitTimeAttribute( + IntegerAttributeCallback callback + ) { + readOffWaitTimeAttribute(chipClusterPtr, callback); + } + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOffWaitTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpOnOffAttribute( + StartUpOnOffAttributeCallback callback + ) { + readStartUpOnOffAttribute(chipClusterPtr, callback); + } + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpOnOffAttribute( + StartUpOnOffAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readOnOffAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeOnOffAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGlobalSceneControlAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeGlobalSceneControlAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOffWaitTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOffWaitTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOffWaitTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpOnOffAttribute(long chipClusterPtr, + StartUpOnOffAttributeCallback callback + ); + + private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, + StartUpOnOffAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OnOffSwitchConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000007L; + + public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSwitchTypeAttribute( + IntegerAttributeCallback callback + ) { + readSwitchTypeAttribute(chipClusterPtr, callback); + } + public void subscribeSwitchTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSwitchActionsAttribute( + IntegerAttributeCallback callback + ) { + readSwitchActionsAttribute(chipClusterPtr, callback); + } + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) { + writeSwitchActionsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSwitchActionsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSwitchTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSwitchTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSwitchActionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSwitchActionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class LevelControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000008L; + + public LevelControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void moveToLevel(DefaultClusterCallback callback + , Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToLevel(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToLevel(DefaultClusterCallback callback + , Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToLevel(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void move(DefaultClusterCallback callback + , Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride) { + move(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); + } + + public void move(DefaultClusterCallback callback + , Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + move(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void step(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void step(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stop(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride) { + stop(chipClusterPtr, callback, optionsMask, optionsOverride, null); + } + + public void stop(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToLevelWithOnOff(DefaultClusterCallback callback + , Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToLevelWithOnOff(DefaultClusterCallback callback + , Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveWithOnOff(DefaultClusterCallback callback + , Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); + } + + public void moveWithOnOff(DefaultClusterCallback callback + , Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepWithOnOff(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepWithOnOff(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stopWithOnOff(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride) { + stopWithOnOff(chipClusterPtr, callback, optionsMask, optionsOverride, null); + } + + public void stopWithOnOff(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stopWithOnOff(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToClosestFrequency(DefaultClusterCallback callback + , Integer frequency) { + moveToClosestFrequency(chipClusterPtr, callback, frequency, null); + } + + public void moveToClosestFrequency(DefaultClusterCallback callback + , Integer frequency + , int timedInvokeTimeoutMs) { + moveToClosestFrequency(chipClusterPtr, callback, frequency, timedInvokeTimeoutMs); + } + private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void move(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void step(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stop(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToClosestFrequency(long chipClusterPtr, DefaultClusterCallback Callback + , Integer frequency + , @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OffTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DefaultMoveRateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpCurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readCurrentLevelAttribute( + CurrentLevelAttributeCallback callback + ) { + readCurrentLevelAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentLevelAttribute( + CurrentLevelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRemainingTimeAttribute( + IntegerAttributeCallback callback + ) { + readRemainingTimeAttribute(chipClusterPtr, callback); + } + public void subscribeRemainingTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinLevelAttribute( + IntegerAttributeCallback callback + ) { + readMinLevelAttribute(chipClusterPtr, callback); + } + public void subscribeMinLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxLevelAttribute( + IntegerAttributeCallback callback + ) { + readMaxLevelAttribute(chipClusterPtr, callback); + } + public void subscribeMaxLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentFrequencyAttribute( + IntegerAttributeCallback callback + ) { + readCurrentFrequencyAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentFrequencyAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinFrequencyAttribute( + IntegerAttributeCallback callback + ) { + readMinFrequencyAttribute(chipClusterPtr, callback); + } + public void subscribeMinFrequencyAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxFrequencyAttribute( + IntegerAttributeCallback callback + ) { + readMaxFrequencyAttribute(chipClusterPtr, callback); + } + public void subscribeMaxFrequencyAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOptionsAttribute( + IntegerAttributeCallback callback + ) { + readOptionsAttribute(chipClusterPtr, callback); + } + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { + writeOptionsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOptionsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnOffTransitionTimeAttribute( + IntegerAttributeCallback callback + ) { + readOnOffTransitionTimeAttribute(chipClusterPtr, callback); + } + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnOffTransitionTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnLevelAttribute( + OnLevelAttributeCallback callback + ) { + readOnLevelAttribute(chipClusterPtr, callback); + } + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeOnLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnLevelAttribute( + OnLevelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnTransitionTimeAttribute( + OnTransitionTimeAttributeCallback callback + ) { + readOnTransitionTimeAttribute(chipClusterPtr, callback); + } + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnTransitionTimeAttribute( + OnTransitionTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOffTransitionTimeAttribute( + OffTransitionTimeAttributeCallback callback + ) { + readOffTransitionTimeAttribute(chipClusterPtr, callback); + } + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOffTransitionTimeAttribute( + OffTransitionTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDefaultMoveRateAttribute( + DefaultMoveRateAttributeCallback callback + ) { + readDefaultMoveRateAttribute(chipClusterPtr, callback); + } + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) { + writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null); + } + + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeDefaultMoveRateAttribute( + DefaultMoveRateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpCurrentLevelAttribute( + StartUpCurrentLevelAttributeCallback callback + ) { + readStartUpCurrentLevelAttribute(chipClusterPtr, callback); + } + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpCurrentLevelAttribute( + StartUpCurrentLevelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readCurrentLevelAttribute(long chipClusterPtr, + CurrentLevelAttributeCallback callback + ); + private native void subscribeCurrentLevelAttribute(long chipClusterPtr, + CurrentLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnOffTransitionTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnOffTransitionTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnLevelAttribute(long chipClusterPtr, + OnLevelAttributeCallback callback + ); + + private native void writeOnLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnLevelAttribute(long chipClusterPtr, + OnLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnTransitionTimeAttribute(long chipClusterPtr, + OnTransitionTimeAttributeCallback callback + ); + + private native void writeOnTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnTransitionTimeAttribute(long chipClusterPtr, + OnTransitionTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOffTransitionTimeAttribute(long chipClusterPtr, + OffTransitionTimeAttributeCallback callback + ); + + private native void writeOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOffTransitionTimeAttribute(long chipClusterPtr, + OffTransitionTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDefaultMoveRateAttribute(long chipClusterPtr, + DefaultMoveRateAttributeCallback callback + ); + + private native void writeDefaultMoveRateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDefaultMoveRateAttribute(long chipClusterPtr, + DefaultMoveRateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readStartUpCurrentLevelAttribute(long chipClusterPtr, + StartUpCurrentLevelAttributeCallback callback + ); + + private native void writeStartUpCurrentLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpCurrentLevelAttribute(long chipClusterPtr, + StartUpCurrentLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BinaryInputBasicCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000000FL; + + public BinaryInputBasicCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readActiveTextAttribute( + CharStringAttributeCallback callback + ) { + readActiveTextAttribute(chipClusterPtr, callback); + } + public void writeActiveTextAttribute(DefaultClusterCallback callback, String value) { + writeActiveTextAttribute(chipClusterPtr, callback, value, null); + } + + public void writeActiveTextAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeActiveTextAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeActiveTextAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { + readDescriptionAttribute(chipClusterPtr, callback); + } + public void writeDescriptionAttribute(DefaultClusterCallback callback, String value) { + writeDescriptionAttribute(chipClusterPtr, callback, value, null); + } + + public void writeDescriptionAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeDescriptionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeDescriptionAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInactiveTextAttribute( + CharStringAttributeCallback callback + ) { + readInactiveTextAttribute(chipClusterPtr, callback); + } + public void writeInactiveTextAttribute(DefaultClusterCallback callback, String value) { + writeInactiveTextAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInactiveTextAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeInactiveTextAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInactiveTextAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInactiveTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOutOfServiceAttribute( + BooleanAttributeCallback callback + ) { + readOutOfServiceAttribute(chipClusterPtr, callback); + } + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) { + writeOutOfServiceAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOutOfServiceAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPolarityAttribute( + IntegerAttributeCallback callback + ) { + readPolarityAttribute(chipClusterPtr, callback); + } + public void subscribePolarityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePolarityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPresentValueAttribute( + BooleanAttributeCallback callback + ) { + readPresentValueAttribute(chipClusterPtr, callback); + } + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) { + writePresentValueAttribute(chipClusterPtr, callback, value, null); + } + + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePresentValueAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReliabilityAttribute( + IntegerAttributeCallback callback + ) { + readReliabilityAttribute(chipClusterPtr, callback); + } + public void writeReliabilityAttribute(DefaultClusterCallback callback, Integer value) { + writeReliabilityAttribute(chipClusterPtr, callback, value, null); + } + + public void writeReliabilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeReliabilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeReliabilityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReliabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStatusFlagsAttribute( + IntegerAttributeCallback callback + ) { + readStatusFlagsAttribute(chipClusterPtr, callback); + } + public void subscribeStatusFlagsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readApplicationTypeAttribute( + LongAttributeCallback callback + ) { + readApplicationTypeAttribute(chipClusterPtr, callback); + } + public void subscribeApplicationTypeAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeApplicationTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readActiveTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeActiveTextAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeDescriptionAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInactiveTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeInactiveTextAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInactiveTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOutOfServiceAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOutOfServiceAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPolarityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePolarityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPresentValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writePresentValueAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePresentValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReliabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeReliabilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeReliabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStatusFlagsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusFlagsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeApplicationTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class PulseWidthModulationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000001CL; + + public PulseWidthModulationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class DescriptorCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000001DL; + + public DescriptorCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface DeviceTypeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ServerListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ClientListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PartsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TagListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readDeviceTypeListAttribute( + DeviceTypeListAttributeCallback callback + ) { + readDeviceTypeListAttribute(chipClusterPtr, callback); + } + public void subscribeDeviceTypeListAttribute( + DeviceTypeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDeviceTypeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readServerListAttribute( + ServerListAttributeCallback callback + ) { + readServerListAttribute(chipClusterPtr, callback); + } + public void subscribeServerListAttribute( + ServerListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClientListAttribute( + ClientListAttributeCallback callback + ) { + readClientListAttribute(chipClusterPtr, callback); + } + public void subscribeClientListAttribute( + ClientListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPartsListAttribute( + PartsListAttributeCallback callback + ) { + readPartsListAttribute(chipClusterPtr, callback); + } + public void subscribePartsListAttribute( + PartsListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTagListAttribute( + TagListAttributeCallback callback + ) { + readTagListAttribute(chipClusterPtr, callback); + } + public void subscribeTagListAttribute( + TagListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTagListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readDeviceTypeListAttribute(long chipClusterPtr, + DeviceTypeListAttributeCallback callback + ); + private native void subscribeDeviceTypeListAttribute(long chipClusterPtr, + DeviceTypeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readServerListAttribute(long chipClusterPtr, + ServerListAttributeCallback callback + ); + private native void subscribeServerListAttribute(long chipClusterPtr, + ServerListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readClientListAttribute(long chipClusterPtr, + ClientListAttributeCallback callback + ); + private native void subscribeClientListAttribute(long chipClusterPtr, + ClientListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPartsListAttribute(long chipClusterPtr, + PartsListAttributeCallback callback + ); + private native void subscribePartsListAttribute(long chipClusterPtr, + PartsListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTagListAttribute(long chipClusterPtr, + TagListAttributeCallback callback + ); + private native void subscribeTagListAttribute(long chipClusterPtr, + TagListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BindingCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000001EL; + + public BindingCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface BindingAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readBindingAttribute( + BindingAttributeCallback callback + ) { + readBindingAttribute(chipClusterPtr, callback, true); + } + public void readBindingAttributeWithFabricFilter( + BindingAttributeCallback callback + , + boolean isFabricFiltered + ) { + readBindingAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void writeBindingAttribute(DefaultClusterCallback callback, ArrayList value) { + writeBindingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBindingAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeBindingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBindingAttribute( + BindingAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBindingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readBindingAttribute(long chipClusterPtr, + BindingAttributeCallback callback + , boolean isFabricFiltered + ); + + private native void writeBindingAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBindingAttribute(long chipClusterPtr, + BindingAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class AccessControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000001FL; + + public AccessControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface AclAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ExtensionAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readAclAttribute( + AclAttributeCallback callback + ) { + readAclAttribute(chipClusterPtr, callback, true); + } + public void readAclAttributeWithFabricFilter( + AclAttributeCallback callback + , + boolean isFabricFiltered + ) { + readAclAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value) { + writeAclAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAclAttribute( + AclAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readExtensionAttribute( + ExtensionAttributeCallback callback + ) { + readExtensionAttribute(chipClusterPtr, callback, true); + } + public void readExtensionAttributeWithFabricFilter( + ExtensionAttributeCallback callback + , + boolean isFabricFiltered + ) { + readExtensionAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value) { + writeExtensionAttribute(chipClusterPtr, callback, value, null); + } + + public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeExtensionAttribute( + ExtensionAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSubjectsPerAccessControlEntryAttribute( + IntegerAttributeCallback callback + ) { + readSubjectsPerAccessControlEntryAttribute(chipClusterPtr, callback); + } + public void subscribeSubjectsPerAccessControlEntryAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSubjectsPerAccessControlEntryAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTargetsPerAccessControlEntryAttribute( + IntegerAttributeCallback callback + ) { + readTargetsPerAccessControlEntryAttribute(chipClusterPtr, callback); + } + public void subscribeTargetsPerAccessControlEntryAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTargetsPerAccessControlEntryAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAccessControlEntriesPerFabricAttribute( + IntegerAttributeCallback callback + ) { + readAccessControlEntriesPerFabricAttribute(chipClusterPtr, callback); + } + public void subscribeAccessControlEntriesPerFabricAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAccessControlEntriesPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readAclAttribute(long chipClusterPtr, + AclAttributeCallback callback + , boolean isFabricFiltered + ); + + private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAclAttribute(long chipClusterPtr, + AclAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readExtensionAttribute(long chipClusterPtr, + ExtensionAttributeCallback callback + , boolean isFabricFiltered + ); + + private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeExtensionAttribute(long chipClusterPtr, + ExtensionAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSubjectsPerAccessControlEntryAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSubjectsPerAccessControlEntryAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTargetsPerAccessControlEntryAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTargetsPerAccessControlEntryAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAccessControlEntriesPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAccessControlEntriesPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ActionsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000025L; + + public ActionsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void instantAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + instantAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void instantAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void instantActionWithTransition(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Integer transitionTime) { + instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null); + } + + public void instantActionWithTransition(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Integer transitionTime + , int timedInvokeTimeoutMs) { + instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); + } + + public void startAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + startAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void startAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void startActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { + startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); + } + + public void startActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + } + + public void stopAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + stopAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void stopAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void pauseAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + pauseAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void pauseAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void pauseActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { + pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); + } + + public void pauseActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + } + + public void resumeAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + resumeAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void resumeAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void enableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + enableAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void enableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void enableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { + enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); + } + + public void enableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + } + + public void disableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { + disableAction(chipClusterPtr, callback, actionID, invokeID, null); + } + + public void disableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { + disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); + } + + public void disableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { + disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); + } + + public void disableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + } + private native void instantAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void startAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void resumeAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void enableAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void disableAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + + public interface ActionListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EndpointListsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readActionListAttribute( + ActionListAttributeCallback callback + ) { + readActionListAttribute(chipClusterPtr, callback); + } + public void subscribeActionListAttribute( + ActionListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEndpointListsAttribute( + EndpointListsAttributeCallback callback + ) { + readEndpointListsAttribute(chipClusterPtr, callback); + } + public void subscribeEndpointListsAttribute( + EndpointListsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEndpointListsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSetupURLAttribute( + CharStringAttributeCallback callback + ) { + readSetupURLAttribute(chipClusterPtr, callback); + } + public void subscribeSetupURLAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSetupURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readActionListAttribute(long chipClusterPtr, + ActionListAttributeCallback callback + ); + private native void subscribeActionListAttribute(long chipClusterPtr, + ActionListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndpointListsAttribute(long chipClusterPtr, + EndpointListsAttributeCallback callback + ); + private native void subscribeEndpointListsAttribute(long chipClusterPtr, + EndpointListsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSetupURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSetupURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BasicInformationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000028L; + + public BasicInformationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void mfgSpecificPing(DefaultClusterCallback callback + ) { + mfgSpecificPing(chipClusterPtr, callback, null); + } + + public void mfgSpecificPing(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + mfgSpecificPing(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void mfgSpecificPing(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readDataModelRevisionAttribute( + IntegerAttributeCallback callback + ) { + readDataModelRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeDataModelRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDataModelRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { + readVendorNameAttribute(chipClusterPtr, callback); + } + public void subscribeVendorNameAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readVendorIDAttribute( + IntegerAttributeCallback callback + ) { + readVendorIDAttribute(chipClusterPtr, callback); + } + public void subscribeVendorIDAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductNameAttribute( + CharStringAttributeCallback callback + ) { + readProductNameAttribute(chipClusterPtr, callback); + } + public void subscribeProductNameAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductIDAttribute( + IntegerAttributeCallback callback + ) { + readProductIDAttribute(chipClusterPtr, callback); + } + public void subscribeProductIDAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNodeLabelAttribute( + CharStringAttributeCallback callback + ) { + readNodeLabelAttribute(chipClusterPtr, callback); + } + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { + writeNodeLabelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNodeLabelAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLocationAttribute( + CharStringAttributeCallback callback + ) { + readLocationAttribute(chipClusterPtr, callback); + } + public void writeLocationAttribute(DefaultClusterCallback callback, String value) { + writeLocationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLocationAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHardwareVersionAttribute( + IntegerAttributeCallback callback + ) { + readHardwareVersionAttribute(chipClusterPtr, callback); + } + public void subscribeHardwareVersionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHardwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { + readHardwareVersionStringAttribute(chipClusterPtr, callback); + } + public void subscribeHardwareVersionStringAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSoftwareVersionAttribute( + LongAttributeCallback callback + ) { + readSoftwareVersionAttribute(chipClusterPtr, callback); + } + public void subscribeSoftwareVersionAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSoftwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { + readSoftwareVersionStringAttribute(chipClusterPtr, callback); + } + public void subscribeSoftwareVersionStringAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readManufacturingDateAttribute( + CharStringAttributeCallback callback + ) { + readManufacturingDateAttribute(chipClusterPtr, callback); + } + public void subscribeManufacturingDateAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPartNumberAttribute( + CharStringAttributeCallback callback + ) { + readPartNumberAttribute(chipClusterPtr, callback); + } + public void subscribePartNumberAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductURLAttribute( + CharStringAttributeCallback callback + ) { + readProductURLAttribute(chipClusterPtr, callback); + } + public void subscribeProductURLAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductLabelAttribute( + CharStringAttributeCallback callback + ) { + readProductLabelAttribute(chipClusterPtr, callback); + } + public void subscribeProductLabelAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSerialNumberAttribute( + CharStringAttributeCallback callback + ) { + readSerialNumberAttribute(chipClusterPtr, callback); + } + public void subscribeSerialNumberAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLocalConfigDisabledAttribute( + BooleanAttributeCallback callback + ) { + readLocalConfigDisabledAttribute(chipClusterPtr, callback); + } + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) { + writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLocalConfigDisabledAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReachableAttribute( + BooleanAttributeCallback callback + ) { + readReachableAttribute(chipClusterPtr, callback); + } + public void subscribeReachableAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUniqueIDAttribute( + CharStringAttributeCallback callback + ) { + readUniqueIDAttribute(chipClusterPtr, callback); + } + public void subscribeUniqueIDAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readDataModelRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDataModelRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeVendorIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLocationAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribePartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocalConfigDisabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeLocalConfigDisabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocalConfigDisabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OtaSoftwareUpdateProviderCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000029L; + + public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void queryImage(QueryImageResponseCallback callback + , Integer vendorID, Integer productID, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider) { + queryImage(chipClusterPtr, callback, vendorID, productID, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null); + } + + public void queryImage(QueryImageResponseCallback callback + , Integer vendorID, Integer productID, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider + , int timedInvokeTimeoutMs) { + queryImage(chipClusterPtr, callback, vendorID, productID, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs); + } + + public void applyUpdateRequest(ApplyUpdateResponseCallback callback + , byte[] updateToken, Long newVersion) { + applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null); + } + + public void applyUpdateRequest(ApplyUpdateResponseCallback callback + , byte[] updateToken, Long newVersion + , int timedInvokeTimeoutMs) { + applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs); + } + + public void notifyUpdateApplied(DefaultClusterCallback callback + , byte[] updateToken, Long softwareVersion) { + notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null); + } + + public void notifyUpdateApplied(DefaultClusterCallback callback + , byte[] updateToken, Long softwareVersion + , int timedInvokeTimeoutMs) { + notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); + } + private native void queryImage(long chipClusterPtr, QueryImageResponseCallback Callback + , Integer vendorID, Integer productID, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider + , @Nullable Integer timedInvokeTimeoutMs); + private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback Callback + , byte[] updateToken, Long newVersion + , @Nullable Integer timedInvokeTimeoutMs); + private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] updateToken, Long softwareVersion + , @Nullable Integer timedInvokeTimeoutMs); + public interface QueryImageResponseCallback { + void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); + + void onError(Exception error); + } + + public interface ApplyUpdateResponseCallback { + void onSuccess(Integer action, Long delayedActionTime); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OtaSoftwareUpdateRequestorCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000002AL; + + public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void announceOTAProvider(DefaultClusterCallback callback + , Long providerNodeID, Integer vendorID, Integer announcementReason, Optional metadataForNode, Integer endpoint) { + announceOTAProvider(chipClusterPtr, callback, providerNodeID, vendorID, announcementReason, metadataForNode, endpoint, null); + } + + public void announceOTAProvider(DefaultClusterCallback callback + , Long providerNodeID, Integer vendorID, Integer announcementReason, Optional metadataForNode, Integer endpoint + , int timedInvokeTimeoutMs) { + announceOTAProvider(chipClusterPtr, callback, providerNodeID, vendorID, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs); + } + private native void announceOTAProvider(long chipClusterPtr, DefaultClusterCallback Callback + , Long providerNodeID, Integer vendorID, Integer announcementReason, Optional metadataForNode, Integer endpoint + , @Nullable Integer timedInvokeTimeoutMs); + + public interface DefaultOTAProvidersAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface UpdateStateProgressAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readDefaultOTAProvidersAttribute( + DefaultOTAProvidersAttributeCallback callback + ) { + readDefaultOTAProvidersAttribute(chipClusterPtr, callback, true); + } + public void readDefaultOTAProvidersAttributeWithFabricFilter( + DefaultOTAProvidersAttributeCallback callback + , + boolean isFabricFiltered + ) { + readDefaultOTAProvidersAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void writeDefaultOTAProvidersAttribute(DefaultClusterCallback callback, ArrayList value) { + writeDefaultOTAProvidersAttribute(chipClusterPtr, callback, value, null); + } + + public void writeDefaultOTAProvidersAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeDefaultOTAProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeDefaultOTAProvidersAttribute( + DefaultOTAProvidersAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDefaultOTAProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpdatePossibleAttribute( + BooleanAttributeCallback callback + ) { + readUpdatePossibleAttribute(chipClusterPtr, callback); + } + public void subscribeUpdatePossibleAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpdateStateAttribute( + IntegerAttributeCallback callback + ) { + readUpdateStateAttribute(chipClusterPtr, callback); + } + public void subscribeUpdateStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpdateStateProgressAttribute( + UpdateStateProgressAttributeCallback callback + ) { + readUpdateStateProgressAttribute(chipClusterPtr, callback); + } + public void subscribeUpdateStateProgressAttribute( + UpdateStateProgressAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readDefaultOTAProvidersAttribute(long chipClusterPtr, + DefaultOTAProvidersAttributeCallback callback + , boolean isFabricFiltered + ); + + private native void writeDefaultOTAProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDefaultOTAProvidersAttribute(long chipClusterPtr, + DefaultOTAProvidersAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readUpdatePossibleAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeUpdatePossibleAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpdateStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeUpdateStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpdateStateProgressAttribute(long chipClusterPtr, + UpdateStateProgressAttributeCallback callback + ); + private native void subscribeUpdateStateProgressAttribute(long chipClusterPtr, + UpdateStateProgressAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class LocalizationConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000002BL; + + public LocalizationConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SupportedLocalesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readActiveLocaleAttribute( + CharStringAttributeCallback callback + ) { + readActiveLocaleAttribute(chipClusterPtr, callback); + } + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { + writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeActiveLocaleAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedLocalesAttribute( + SupportedLocalesAttributeCallback callback + ) { + readSupportedLocalesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedLocalesAttribute( + SupportedLocalesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readActiveLocaleAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveLocaleAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedLocalesAttribute(long chipClusterPtr, + SupportedLocalesAttributeCallback callback + ); + private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, + SupportedLocalesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class TimeFormatLocalizationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000002CL; + + public TimeFormatLocalizationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SupportedCalendarTypesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readHourFormatAttribute( + IntegerAttributeCallback callback + ) { + readHourFormatAttribute(chipClusterPtr, callback); + } + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) { + writeHourFormatAttribute(chipClusterPtr, callback, value, null); + } + + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeHourFormatAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveCalendarTypeAttribute( + IntegerAttributeCallback callback + ) { + readActiveCalendarTypeAttribute(chipClusterPtr, callback); + } + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) { + writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeActiveCalendarTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedCalendarTypesAttribute( + SupportedCalendarTypesAttributeCallback callback + ) { + readSupportedCalendarTypesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedCalendarTypesAttribute( + SupportedCalendarTypesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readHourFormatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeHourFormatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeHourFormatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveCalendarTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeActiveCalendarTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveCalendarTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedCalendarTypesAttribute(long chipClusterPtr, + SupportedCalendarTypesAttributeCallback callback + ); + private native void subscribeSupportedCalendarTypesAttribute(long chipClusterPtr, + SupportedCalendarTypesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class UnitLocalizationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000002DL; + + public UnitLocalizationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readTemperatureUnitAttribute( + IntegerAttributeCallback callback + ) { + readTemperatureUnitAttribute(chipClusterPtr, callback); + } + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) { + writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null); + } + + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeTemperatureUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readTemperatureUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureUnitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class PowerSourceConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000002EL; + + public PowerSourceConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SourcesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSourcesAttribute( + SourcesAttributeCallback callback + ) { + readSourcesAttribute(chipClusterPtr, callback); + } + public void subscribeSourcesAttribute( + SourcesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSourcesAttribute(long chipClusterPtr, + SourcesAttributeCallback callback + ); + private native void subscribeSourcesAttribute(long chipClusterPtr, + SourcesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class PowerSourceCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000002FL; + + public PowerSourceCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface WiredAssessedInputVoltageAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface WiredAssessedInputFrequencyAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface WiredAssessedCurrentAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveWiredFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BatVoltageAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BatPercentRemainingAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BatTimeRemainingAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveBatFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BatTimeToFullChargeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BatChargingCurrentAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveBatChargeFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EndpointListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readStatusAttribute( + IntegerAttributeCallback callback + ) { + readStatusAttribute(chipClusterPtr, callback); + } + public void subscribeStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOrderAttribute( + IntegerAttributeCallback callback + ) { + readOrderAttribute(chipClusterPtr, callback); + } + public void subscribeOrderAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { + readDescriptionAttribute(chipClusterPtr, callback); + } + public void subscribeDescriptionAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredAssessedInputVoltageAttribute( + WiredAssessedInputVoltageAttributeCallback callback + ) { + readWiredAssessedInputVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeWiredAssessedInputVoltageAttribute( + WiredAssessedInputVoltageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeWiredAssessedInputVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredAssessedInputFrequencyAttribute( + WiredAssessedInputFrequencyAttributeCallback callback + ) { + readWiredAssessedInputFrequencyAttribute(chipClusterPtr, callback); + } + public void subscribeWiredAssessedInputFrequencyAttribute( + WiredAssessedInputFrequencyAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeWiredAssessedInputFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredCurrentTypeAttribute( + IntegerAttributeCallback callback + ) { + readWiredCurrentTypeAttribute(chipClusterPtr, callback); + } + public void subscribeWiredCurrentTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWiredCurrentTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredAssessedCurrentAttribute( + WiredAssessedCurrentAttributeCallback callback + ) { + readWiredAssessedCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeWiredAssessedCurrentAttribute( + WiredAssessedCurrentAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeWiredAssessedCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredNominalVoltageAttribute( + LongAttributeCallback callback + ) { + readWiredNominalVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeWiredNominalVoltageAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWiredNominalVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredMaximumCurrentAttribute( + LongAttributeCallback callback + ) { + readWiredMaximumCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeWiredMaximumCurrentAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWiredMaximumCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiredPresentAttribute( + BooleanAttributeCallback callback + ) { + readWiredPresentAttribute(chipClusterPtr, callback); + } + public void subscribeWiredPresentAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWiredPresentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveWiredFaultsAttribute( + ActiveWiredFaultsAttributeCallback callback + ) { + readActiveWiredFaultsAttribute(chipClusterPtr, callback); + } + public void subscribeActiveWiredFaultsAttribute( + ActiveWiredFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveWiredFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatVoltageAttribute( + BatVoltageAttributeCallback callback + ) { + readBatVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeBatVoltageAttribute( + BatVoltageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBatVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatPercentRemainingAttribute( + BatPercentRemainingAttributeCallback callback + ) { + readBatPercentRemainingAttribute(chipClusterPtr, callback); + } + public void subscribeBatPercentRemainingAttribute( + BatPercentRemainingAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBatPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatTimeRemainingAttribute( + BatTimeRemainingAttributeCallback callback + ) { + readBatTimeRemainingAttribute(chipClusterPtr, callback); + } + public void subscribeBatTimeRemainingAttribute( + BatTimeRemainingAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBatTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatChargeLevelAttribute( + IntegerAttributeCallback callback + ) { + readBatChargeLevelAttribute(chipClusterPtr, callback); + } + public void subscribeBatChargeLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatReplacementNeededAttribute( + BooleanAttributeCallback callback + ) { + readBatReplacementNeededAttribute(chipClusterPtr, callback); + } + public void subscribeBatReplacementNeededAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatReplacementNeededAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatReplaceabilityAttribute( + IntegerAttributeCallback callback + ) { + readBatReplaceabilityAttribute(chipClusterPtr, callback); + } + public void subscribeBatReplaceabilityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatReplaceabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatPresentAttribute( + BooleanAttributeCallback callback + ) { + readBatPresentAttribute(chipClusterPtr, callback); + } + public void subscribeBatPresentAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatPresentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveBatFaultsAttribute( + ActiveBatFaultsAttributeCallback callback + ) { + readActiveBatFaultsAttribute(chipClusterPtr, callback); + } + public void subscribeActiveBatFaultsAttribute( + ActiveBatFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveBatFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatReplacementDescriptionAttribute( + CharStringAttributeCallback callback + ) { + readBatReplacementDescriptionAttribute(chipClusterPtr, callback); + } + public void subscribeBatReplacementDescriptionAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatReplacementDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatCommonDesignationAttribute( + IntegerAttributeCallback callback + ) { + readBatCommonDesignationAttribute(chipClusterPtr, callback); + } + public void subscribeBatCommonDesignationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatCommonDesignationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatANSIDesignationAttribute( + CharStringAttributeCallback callback + ) { + readBatANSIDesignationAttribute(chipClusterPtr, callback); + } + public void subscribeBatANSIDesignationAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatANSIDesignationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatIECDesignationAttribute( + CharStringAttributeCallback callback + ) { + readBatIECDesignationAttribute(chipClusterPtr, callback); + } + public void subscribeBatIECDesignationAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatIECDesignationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatApprovedChemistryAttribute( + IntegerAttributeCallback callback + ) { + readBatApprovedChemistryAttribute(chipClusterPtr, callback); + } + public void subscribeBatApprovedChemistryAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatApprovedChemistryAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatCapacityAttribute( + LongAttributeCallback callback + ) { + readBatCapacityAttribute(chipClusterPtr, callback); + } + public void subscribeBatCapacityAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatQuantityAttribute( + IntegerAttributeCallback callback + ) { + readBatQuantityAttribute(chipClusterPtr, callback); + } + public void subscribeBatQuantityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatQuantityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatChargeStateAttribute( + IntegerAttributeCallback callback + ) { + readBatChargeStateAttribute(chipClusterPtr, callback); + } + public void subscribeBatChargeStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatTimeToFullChargeAttribute( + BatTimeToFullChargeAttributeCallback callback + ) { + readBatTimeToFullChargeAttribute(chipClusterPtr, callback); + } + public void subscribeBatTimeToFullChargeAttribute( + BatTimeToFullChargeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBatTimeToFullChargeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatFunctionalWhileChargingAttribute( + BooleanAttributeCallback callback + ) { + readBatFunctionalWhileChargingAttribute(chipClusterPtr, callback); + } + public void subscribeBatFunctionalWhileChargingAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatFunctionalWhileChargingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatChargingCurrentAttribute( + BatChargingCurrentAttributeCallback callback + ) { + readBatChargingCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeBatChargingCurrentAttribute( + BatChargingCurrentAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBatChargingCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveBatChargeFaultsAttribute( + ActiveBatChargeFaultsAttributeCallback callback + ) { + readActiveBatChargeFaultsAttribute(chipClusterPtr, callback); + } + public void subscribeActiveBatChargeFaultsAttribute( + ActiveBatChargeFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveBatChargeFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEndpointListAttribute( + EndpointListAttributeCallback callback + ) { + readEndpointListAttribute(chipClusterPtr, callback); + } + public void subscribeEndpointListAttribute( + EndpointListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOrderAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOrderAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWiredAssessedInputVoltageAttribute(long chipClusterPtr, + WiredAssessedInputVoltageAttributeCallback callback + ); + private native void subscribeWiredAssessedInputVoltageAttribute(long chipClusterPtr, + WiredAssessedInputVoltageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWiredAssessedInputFrequencyAttribute(long chipClusterPtr, + WiredAssessedInputFrequencyAttributeCallback callback + ); + private native void subscribeWiredAssessedInputFrequencyAttribute(long chipClusterPtr, + WiredAssessedInputFrequencyAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWiredCurrentTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWiredCurrentTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWiredAssessedCurrentAttribute(long chipClusterPtr, + WiredAssessedCurrentAttributeCallback callback + ); + private native void subscribeWiredAssessedCurrentAttribute(long chipClusterPtr, + WiredAssessedCurrentAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWiredNominalVoltageAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeWiredNominalVoltageAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWiredMaximumCurrentAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeWiredMaximumCurrentAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWiredPresentAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeWiredPresentAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveWiredFaultsAttribute(long chipClusterPtr, + ActiveWiredFaultsAttributeCallback callback + ); + private native void subscribeActiveWiredFaultsAttribute(long chipClusterPtr, + ActiveWiredFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatVoltageAttribute(long chipClusterPtr, + BatVoltageAttributeCallback callback + ); + private native void subscribeBatVoltageAttribute(long chipClusterPtr, + BatVoltageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatPercentRemainingAttribute(long chipClusterPtr, + BatPercentRemainingAttributeCallback callback + ); + private native void subscribeBatPercentRemainingAttribute(long chipClusterPtr, + BatPercentRemainingAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatTimeRemainingAttribute(long chipClusterPtr, + BatTimeRemainingAttributeCallback callback + ); + private native void subscribeBatTimeRemainingAttribute(long chipClusterPtr, + BatTimeRemainingAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatChargeLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatChargeLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatReplacementNeededAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeBatReplacementNeededAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatReplaceabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatReplaceabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatPresentAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeBatPresentAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveBatFaultsAttribute(long chipClusterPtr, + ActiveBatFaultsAttributeCallback callback + ); + private native void subscribeActiveBatFaultsAttribute(long chipClusterPtr, + ActiveBatFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatReplacementDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeBatReplacementDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatCommonDesignationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatCommonDesignationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatANSIDesignationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeBatANSIDesignationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatIECDesignationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeBatIECDesignationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatApprovedChemistryAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatApprovedChemistryAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatCapacityAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBatCapacityAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatQuantityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatQuantityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatChargeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatChargeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatTimeToFullChargeAttribute(long chipClusterPtr, + BatTimeToFullChargeAttributeCallback callback + ); + private native void subscribeBatTimeToFullChargeAttribute(long chipClusterPtr, + BatTimeToFullChargeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatFunctionalWhileChargingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeBatFunctionalWhileChargingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatChargingCurrentAttribute(long chipClusterPtr, + BatChargingCurrentAttributeCallback callback + ); + private native void subscribeBatChargingCurrentAttribute(long chipClusterPtr, + BatChargingCurrentAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveBatChargeFaultsAttribute(long chipClusterPtr, + ActiveBatChargeFaultsAttributeCallback callback + ); + private native void subscribeActiveBatChargeFaultsAttribute(long chipClusterPtr, + ActiveBatChargeFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndpointListAttribute(long chipClusterPtr, + EndpointListAttributeCallback callback + ); + private native void subscribeEndpointListAttribute(long chipClusterPtr, + EndpointListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class GeneralCommissioningCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000030L; + + public GeneralCommissioningCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void armFailSafe(ArmFailSafeResponseCallback callback + , Integer expiryLengthSeconds, Long breadcrumb) { + armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, null); + } + + public void armFailSafe(ArmFailSafeResponseCallback callback + , Integer expiryLengthSeconds, Long breadcrumb + , int timedInvokeTimeoutMs) { + armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timedInvokeTimeoutMs); + } + + public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback + , Integer newRegulatoryConfig, String countryCode, Long breadcrumb) { + setRegulatoryConfig(chipClusterPtr, callback, newRegulatoryConfig, countryCode, breadcrumb, null); + } + + public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback + , Integer newRegulatoryConfig, String countryCode, Long breadcrumb + , int timedInvokeTimeoutMs) { + setRegulatoryConfig(chipClusterPtr, callback, newRegulatoryConfig, countryCode, breadcrumb, timedInvokeTimeoutMs); + } + + public void commissioningComplete(CommissioningCompleteResponseCallback callback + ) { + commissioningComplete(chipClusterPtr, callback, null); + } + + public void commissioningComplete(CommissioningCompleteResponseCallback callback + + , int timedInvokeTimeoutMs) { + commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback Callback + , Integer expiryLengthSeconds, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback + , Integer newRegulatoryConfig, String countryCode, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface ArmFailSafeResponseCallback { + void onSuccess(Integer errorCode, String debugText); + + void onError(Exception error); + } + + public interface SetRegulatoryConfigResponseCallback { + void onSuccess(Integer errorCode, String debugText); + + void onError(Exception error); + } + + public interface CommissioningCompleteResponseCallback { + void onSuccess(Integer errorCode, String debugText); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readBreadcrumbAttribute( + LongAttributeCallback callback + ) { + readBreadcrumbAttribute(chipClusterPtr, callback); + } + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) { + writeBreadcrumbAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBreadcrumbAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRegulatoryConfigAttribute( + IntegerAttributeCallback callback + ) { + readRegulatoryConfigAttribute(chipClusterPtr, callback); + } + public void subscribeRegulatoryConfigAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLocationCapabilityAttribute( + IntegerAttributeCallback callback + ) { + readLocationCapabilityAttribute(chipClusterPtr, callback); + } + public void subscribeLocationCapabilityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportsConcurrentConnectionAttribute( + BooleanAttributeCallback callback + ) { + readSupportsConcurrentConnectionAttribute(chipClusterPtr, callback); + } + public void subscribeSupportsConcurrentConnectionAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportsConcurrentConnectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readBreadcrumbAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBreadcrumbAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBreadcrumbAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRegulatoryConfigAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRegulatoryConfigAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocationCapabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLocationCapabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportsConcurrentConnectionAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeSupportsConcurrentConnectionAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class NetworkCommissioningCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000031L; + + public NetworkCommissioningCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void scanNetworks(ScanNetworksResponseCallback callback + , @Nullable Optional ssid, Optional breadcrumb) { + scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null); + } + + public void scanNetworks(ScanNetworksResponseCallback callback + , @Nullable Optional ssid, Optional breadcrumb + , int timedInvokeTimeoutMs) { + scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs); + } + + public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback + , byte[] ssid, byte[] credentials, Optional breadcrumb) { + addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null); + } + + public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback + , byte[] ssid, byte[] credentials, Optional breadcrumb + , int timedInvokeTimeoutMs) { + addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); + } + + public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback + , byte[] operationalDataset, Optional breadcrumb) { + addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null); + } + + public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback + , byte[] operationalDataset, Optional breadcrumb + , int timedInvokeTimeoutMs) { + addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); + } + + public void removeNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Optional breadcrumb) { + removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); + } + + public void removeNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Optional breadcrumb + , int timedInvokeTimeoutMs) { + removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); + } + + public void connectNetwork(ConnectNetworkResponseCallback callback + , byte[] networkID, Optional breadcrumb) { + connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); + } + + public void connectNetwork(ConnectNetworkResponseCallback callback + , byte[] networkID, Optional breadcrumb + , int timedInvokeTimeoutMs) { + connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); + } + + public void reorderNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Integer networkIndex, Optional breadcrumb) { + reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null); + } + + public void reorderNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Integer networkIndex, Optional breadcrumb + , int timedInvokeTimeoutMs) { + reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); + } + private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback Callback + , @Nullable Optional ssid, Optional breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] ssid, byte[] credentials, Optional breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] operationalDataset, Optional breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] networkID, Optional breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback Callback + , byte[] networkID, Optional breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] networkID, Integer networkIndex, Optional breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + public interface ScanNetworksResponseCallback { + void onSuccess(Integer networkingStatus, Optional debugText, Optional> wiFiScanResults, Optional> threadScanResults); + + void onError(Exception error); + } + + public interface NetworkConfigResponseCallback { + void onSuccess(Integer networkingStatus, Optional debugText, Optional networkIndex); + + void onError(Exception error); + } + + public interface ConnectNetworkResponseCallback { + void onSuccess(Integer networkingStatus, Optional debugText, @Nullable Long errorValue); + + void onError(Exception error); + } + + + public interface NetworksAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LastNetworkingStatusAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LastNetworkIDAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LastConnectErrorValueAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMaxNetworksAttribute( + IntegerAttributeCallback callback + ) { + readMaxNetworksAttribute(chipClusterPtr, callback); + } + public void subscribeMaxNetworksAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNetworksAttribute( + NetworksAttributeCallback callback + ) { + readNetworksAttribute(chipClusterPtr, callback); + } + public void subscribeNetworksAttribute( + NetworksAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readScanMaxTimeSecondsAttribute( + IntegerAttributeCallback callback + ) { + readScanMaxTimeSecondsAttribute(chipClusterPtr, callback); + } + public void subscribeScanMaxTimeSecondsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readConnectMaxTimeSecondsAttribute( + IntegerAttributeCallback callback + ) { + readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback); + } + public void subscribeConnectMaxTimeSecondsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInterfaceEnabledAttribute( + BooleanAttributeCallback callback + ) { + readInterfaceEnabledAttribute(chipClusterPtr, callback); + } + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) { + writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInterfaceEnabledAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLastNetworkingStatusAttribute( + LastNetworkingStatusAttributeCallback callback + ) { + readLastNetworkingStatusAttribute(chipClusterPtr, callback); + } + public void subscribeLastNetworkingStatusAttribute( + LastNetworkingStatusAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLastNetworkIDAttribute( + LastNetworkIDAttributeCallback callback + ) { + readLastNetworkIDAttribute(chipClusterPtr, callback); + } + public void subscribeLastNetworkIDAttribute( + LastNetworkIDAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLastConnectErrorValueAttribute( + LastConnectErrorValueAttributeCallback callback + ) { + readLastConnectErrorValueAttribute(chipClusterPtr, callback); + } + public void subscribeLastConnectErrorValueAttribute( + LastConnectErrorValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMaxNetworksAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxNetworksAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNetworksAttribute(long chipClusterPtr, + NetworksAttributeCallback callback + ); + private native void subscribeNetworksAttribute(long chipClusterPtr, + NetworksAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readScanMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeScanMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readConnectMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConnectMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInterfaceEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeInterfaceEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInterfaceEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastNetworkingStatusAttribute(long chipClusterPtr, + LastNetworkingStatusAttributeCallback callback + ); + private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, + LastNetworkingStatusAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLastNetworkIDAttribute(long chipClusterPtr, + LastNetworkIDAttributeCallback callback + ); + private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, + LastNetworkIDAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLastConnectErrorValueAttribute(long chipClusterPtr, + LastConnectErrorValueAttributeCallback callback + ); + private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, + LastConnectErrorValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class DiagnosticLogsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000032L; + + public DiagnosticLogsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void retrieveLogsRequest(RetrieveLogsResponseCallback callback + , Integer intent, Integer requestedProtocol, Optional transferFileDesignator) { + retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); + } + + public void retrieveLogsRequest(RetrieveLogsResponseCallback callback + , Integer intent, Integer requestedProtocol, Optional transferFileDesignator + , int timedInvokeTimeoutMs) { + retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs); + } + private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback Callback + , Integer intent, Integer requestedProtocol, Optional transferFileDesignator + , @Nullable Integer timedInvokeTimeoutMs); + public interface RetrieveLogsResponseCallback { + void onSuccess(Integer status, byte[] logContent, Optional UTCTimeStamp, Optional timeSinceBoot); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class GeneralDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000033L; + + public GeneralDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void testEventTrigger(DefaultClusterCallback callback + , byte[] enableKey, Long eventTrigger) { + testEventTrigger(chipClusterPtr, callback, enableKey, eventTrigger, null); + } + + public void testEventTrigger(DefaultClusterCallback callback + , byte[] enableKey, Long eventTrigger + , int timedInvokeTimeoutMs) { + testEventTrigger(chipClusterPtr, callback, enableKey, eventTrigger, timedInvokeTimeoutMs); + } + private native void testEventTrigger(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] enableKey, Long eventTrigger + , @Nullable Integer timedInvokeTimeoutMs); + + public interface NetworkInterfacesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveHardwareFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveRadioFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveNetworkFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback + ) { + readNetworkInterfacesAttribute(chipClusterPtr, callback); + } + public void subscribeNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRebootCountAttribute( + IntegerAttributeCallback callback + ) { + readRebootCountAttribute(chipClusterPtr, callback); + } + public void subscribeRebootCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpTimeAttribute( + LongAttributeCallback callback + ) { + readUpTimeAttribute(chipClusterPtr, callback); + } + public void subscribeUpTimeAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTotalOperationalHoursAttribute( + LongAttributeCallback callback + ) { + readTotalOperationalHoursAttribute(chipClusterPtr, callback); + } + public void subscribeTotalOperationalHoursAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBootReasonAttribute( + IntegerAttributeCallback callback + ) { + readBootReasonAttribute(chipClusterPtr, callback); + } + public void subscribeBootReasonAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBootReasonAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveHardwareFaultsAttribute( + ActiveHardwareFaultsAttributeCallback callback + ) { + readActiveHardwareFaultsAttribute(chipClusterPtr, callback); + } + public void subscribeActiveHardwareFaultsAttribute( + ActiveHardwareFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveRadioFaultsAttribute( + ActiveRadioFaultsAttributeCallback callback + ) { + readActiveRadioFaultsAttribute(chipClusterPtr, callback); + } + public void subscribeActiveRadioFaultsAttribute( + ActiveRadioFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveNetworkFaultsAttribute( + ActiveNetworkFaultsAttributeCallback callback + ) { + readActiveNetworkFaultsAttribute(chipClusterPtr, callback); + } + public void subscribeActiveNetworkFaultsAttribute( + ActiveNetworkFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTestEventTriggersEnabledAttribute( + BooleanAttributeCallback callback + ) { + readTestEventTriggersEnabledAttribute(chipClusterPtr, callback); + } + public void subscribeTestEventTriggersEnabledAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTestEventTriggersEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageWearCountAttribute( + LongAttributeCallback callback + ) { + readAverageWearCountAttribute(chipClusterPtr, callback); + } + public void subscribeAverageWearCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageWearCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readNetworkInterfacesAttribute(long chipClusterPtr, + NetworkInterfacesAttributeCallback callback + ); + private native void subscribeNetworkInterfacesAttribute(long chipClusterPtr, + NetworkInterfacesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRebootCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRebootCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeUpTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalOperationalHoursAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBootReasonAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBootReasonAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveHardwareFaultsAttribute(long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback + ); + private native void subscribeActiveHardwareFaultsAttribute(long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveRadioFaultsAttribute(long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback + ); + private native void subscribeActiveRadioFaultsAttribute(long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveNetworkFaultsAttribute(long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback callback + ); + private native void subscribeActiveNetworkFaultsAttribute(long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTestEventTriggersEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeTestEventTriggersEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageWearCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageWearCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class SoftwareDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000034L; + + public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetWatermarks(DefaultClusterCallback callback + ) { + resetWatermarks(chipClusterPtr, callback, null); + } + + public void resetWatermarks(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface ThreadMetricsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readThreadMetricsAttribute( + ThreadMetricsAttributeCallback callback + ) { + readThreadMetricsAttribute(chipClusterPtr, callback); + } + public void subscribeThreadMetricsAttribute( + ThreadMetricsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentHeapFreeAttribute( + LongAttributeCallback callback + ) { + readCurrentHeapFreeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentHeapFreeAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentHeapUsedAttribute( + LongAttributeCallback callback + ) { + readCurrentHeapUsedAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentHeapUsedAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentHeapHighWatermarkAttribute( + LongAttributeCallback callback + ) { + readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentHeapHighWatermarkAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readThreadMetricsAttribute(long chipClusterPtr, + ThreadMetricsAttributeCallback callback + ); + private native void subscribeThreadMetricsAttribute(long chipClusterPtr, + ThreadMetricsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentHeapFreeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapFreeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentHeapUsedAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapUsedAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentHeapHighWatermarkAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapHighWatermarkAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000035L; + + public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCounts(DefaultClusterCallback callback + ) { + resetCounts(chipClusterPtr, callback, null); + } + + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface ChannelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface RoutingRoleAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NetworkNameAttributeCallback { + void onSuccess(@Nullable String value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PanIdAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ExtendedPanIdAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MeshLocalPrefixAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NeighborTableAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface RouteTableAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PartitionIdAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface WeightingAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DataVersionAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StableDataVersionAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LeaderRouterIdAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveTimestampAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PendingTimestampAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DelayAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ChannelPage0MaskAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ActiveNetworkFaultsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readChannelAttribute( + ChannelAttributeCallback callback + ) { + readChannelAttribute(chipClusterPtr, callback); + } + public void subscribeChannelAttribute( + ChannelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRoutingRoleAttribute( + RoutingRoleAttributeCallback callback + ) { + readRoutingRoleAttribute(chipClusterPtr, callback); + } + public void subscribeRoutingRoleAttribute( + RoutingRoleAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNetworkNameAttribute( + NetworkNameAttributeCallback callback + ) { + readNetworkNameAttribute(chipClusterPtr, callback); + } + public void subscribeNetworkNameAttribute( + NetworkNameAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPanIdAttribute( + PanIdAttributeCallback callback + ) { + readPanIdAttribute(chipClusterPtr, callback); + } + public void subscribePanIdAttribute( + PanIdAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readExtendedPanIdAttribute( + ExtendedPanIdAttributeCallback callback + ) { + readExtendedPanIdAttribute(chipClusterPtr, callback); + } + public void subscribeExtendedPanIdAttribute( + ExtendedPanIdAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeshLocalPrefixAttribute( + MeshLocalPrefixAttributeCallback callback + ) { + readMeshLocalPrefixAttribute(chipClusterPtr, callback); + } + public void subscribeMeshLocalPrefixAttribute( + MeshLocalPrefixAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { + readOverrunCountAttribute(chipClusterPtr, callback); + } + public void subscribeOverrunCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNeighborTableAttribute( + NeighborTableAttributeCallback callback + ) { + readNeighborTableAttribute(chipClusterPtr, callback); + } + public void subscribeNeighborTableAttribute( + NeighborTableAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNeighborTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRouteTableAttribute( + RouteTableAttributeCallback callback + ) { + readRouteTableAttribute(chipClusterPtr, callback); + } + public void subscribeRouteTableAttribute( + RouteTableAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeRouteTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPartitionIdAttribute( + PartitionIdAttributeCallback callback + ) { + readPartitionIdAttribute(chipClusterPtr, callback); + } + public void subscribePartitionIdAttribute( + PartitionIdAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWeightingAttribute( + WeightingAttributeCallback callback + ) { + readWeightingAttribute(chipClusterPtr, callback); + } + public void subscribeWeightingAttribute( + WeightingAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDataVersionAttribute( + DataVersionAttributeCallback callback + ) { + readDataVersionAttribute(chipClusterPtr, callback); + } + public void subscribeDataVersionAttribute( + DataVersionAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStableDataVersionAttribute( + StableDataVersionAttributeCallback callback + ) { + readStableDataVersionAttribute(chipClusterPtr, callback); + } + public void subscribeStableDataVersionAttribute( + StableDataVersionAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLeaderRouterIdAttribute( + LeaderRouterIdAttributeCallback callback + ) { + readLeaderRouterIdAttribute(chipClusterPtr, callback); + } + public void subscribeLeaderRouterIdAttribute( + LeaderRouterIdAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDetachedRoleCountAttribute( + IntegerAttributeCallback callback + ) { + readDetachedRoleCountAttribute(chipClusterPtr, callback); + } + public void subscribeDetachedRoleCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChildRoleCountAttribute( + IntegerAttributeCallback callback + ) { + readChildRoleCountAttribute(chipClusterPtr, callback); + } + public void subscribeChildRoleCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRouterRoleCountAttribute( + IntegerAttributeCallback callback + ) { + readRouterRoleCountAttribute(chipClusterPtr, callback); + } + public void subscribeRouterRoleCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLeaderRoleCountAttribute( + IntegerAttributeCallback callback + ) { + readLeaderRoleCountAttribute(chipClusterPtr, callback); + } + public void subscribeLeaderRoleCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttachAttemptCountAttribute( + IntegerAttributeCallback callback + ) { + readAttachAttemptCountAttribute(chipClusterPtr, callback); + } + public void subscribeAttachAttemptCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPartitionIdChangeCountAttribute( + IntegerAttributeCallback callback + ) { + readPartitionIdChangeCountAttribute(chipClusterPtr, callback); + } + public void subscribePartitionIdChangeCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBetterPartitionAttachAttemptCountAttribute( + IntegerAttributeCallback callback + ) { + readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback); + } + public void subscribeBetterPartitionAttachAttemptCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readParentChangeCountAttribute( + IntegerAttributeCallback callback + ) { + readParentChangeCountAttribute(chipClusterPtr, callback); + } + public void subscribeParentChangeCountAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxTotalCountAttribute( + LongAttributeCallback callback + ) { + readTxTotalCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxTotalCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxUnicastCountAttribute( + LongAttributeCallback callback + ) { + readTxUnicastCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxUnicastCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxBroadcastCountAttribute( + LongAttributeCallback callback + ) { + readTxBroadcastCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxBroadcastCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxAckRequestedCountAttribute( + LongAttributeCallback callback + ) { + readTxAckRequestedCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxAckRequestedCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxAckedCountAttribute( + LongAttributeCallback callback + ) { + readTxAckedCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxAckedCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxNoAckRequestedCountAttribute( + LongAttributeCallback callback + ) { + readTxNoAckRequestedCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxNoAckRequestedCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxDataCountAttribute( + LongAttributeCallback callback + ) { + readTxDataCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxDataCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxDataPollCountAttribute( + LongAttributeCallback callback + ) { + readTxDataPollCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxDataPollCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxBeaconCountAttribute( + LongAttributeCallback callback + ) { + readTxBeaconCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxBeaconCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxBeaconRequestCountAttribute( + LongAttributeCallback callback + ) { + readTxBeaconRequestCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxBeaconRequestCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxOtherCountAttribute( + LongAttributeCallback callback + ) { + readTxOtherCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxOtherCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxRetryCountAttribute( + LongAttributeCallback callback + ) { + readTxRetryCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxRetryCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxDirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback + ) { + readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxDirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxIndirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback + ) { + readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxIndirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxErrCcaCountAttribute( + LongAttributeCallback callback + ) { + readTxErrCcaCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxErrCcaCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxErrAbortCountAttribute( + LongAttributeCallback callback + ) { + readTxErrAbortCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxErrAbortCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxErrBusyChannelCountAttribute( + LongAttributeCallback callback + ) { + readTxErrBusyChannelCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxErrBusyChannelCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxTotalCountAttribute( + LongAttributeCallback callback + ) { + readRxTotalCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxTotalCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxUnicastCountAttribute( + LongAttributeCallback callback + ) { + readRxUnicastCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxUnicastCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxBroadcastCountAttribute( + LongAttributeCallback callback + ) { + readRxBroadcastCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxBroadcastCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxDataCountAttribute( + LongAttributeCallback callback + ) { + readRxDataCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxDataCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxDataPollCountAttribute( + LongAttributeCallback callback + ) { + readRxDataPollCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxDataPollCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxBeaconCountAttribute( + LongAttributeCallback callback + ) { + readRxBeaconCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxBeaconCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxBeaconRequestCountAttribute( + LongAttributeCallback callback + ) { + readRxBeaconRequestCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxBeaconRequestCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxOtherCountAttribute( + LongAttributeCallback callback + ) { + readRxOtherCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxOtherCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxAddressFilteredCountAttribute( + LongAttributeCallback callback + ) { + readRxAddressFilteredCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxAddressFilteredCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxDestAddrFilteredCountAttribute( + LongAttributeCallback callback + ) { + readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxDestAddrFilteredCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxDuplicatedCountAttribute( + LongAttributeCallback callback + ) { + readRxDuplicatedCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxDuplicatedCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxErrNoFrameCountAttribute( + LongAttributeCallback callback + ) { + readRxErrNoFrameCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxErrNoFrameCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxErrUnknownNeighborCountAttribute( + LongAttributeCallback callback + ) { + readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxErrUnknownNeighborCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxErrInvalidSrcAddrCountAttribute( + LongAttributeCallback callback + ) { + readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxErrInvalidSrcAddrCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxErrSecCountAttribute( + LongAttributeCallback callback + ) { + readRxErrSecCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxErrSecCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxErrFcsCountAttribute( + LongAttributeCallback callback + ) { + readRxErrFcsCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxErrFcsCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRxErrOtherCountAttribute( + LongAttributeCallback callback + ) { + readRxErrOtherCountAttribute(chipClusterPtr, callback); + } + public void subscribeRxErrOtherCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveTimestampAttribute( + ActiveTimestampAttributeCallback callback + ) { + readActiveTimestampAttribute(chipClusterPtr, callback); + } + public void subscribeActiveTimestampAttribute( + ActiveTimestampAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPendingTimestampAttribute( + PendingTimestampAttributeCallback callback + ) { + readPendingTimestampAttribute(chipClusterPtr, callback); + } + public void subscribePendingTimestampAttribute( + PendingTimestampAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDelayAttribute( + DelayAttributeCallback callback + ) { + readDelayAttribute(chipClusterPtr, callback); + } + public void subscribeDelayAttribute( + DelayAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChannelPage0MaskAttribute( + ChannelPage0MaskAttributeCallback callback + ) { + readChannelPage0MaskAttribute(chipClusterPtr, callback); + } + public void subscribeChannelPage0MaskAttribute( + ChannelPage0MaskAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeChannelPage0MaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback + ) { + readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); + } + public void subscribeActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readChannelAttribute(long chipClusterPtr, + ChannelAttributeCallback callback + ); + private native void subscribeChannelAttribute(long chipClusterPtr, + ChannelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRoutingRoleAttribute(long chipClusterPtr, + RoutingRoleAttributeCallback callback + ); + private native void subscribeRoutingRoleAttribute(long chipClusterPtr, + RoutingRoleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNetworkNameAttribute(long chipClusterPtr, + NetworkNameAttributeCallback callback + ); + private native void subscribeNetworkNameAttribute(long chipClusterPtr, + NetworkNameAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPanIdAttribute(long chipClusterPtr, + PanIdAttributeCallback callback + ); + private native void subscribePanIdAttribute(long chipClusterPtr, + PanIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readExtendedPanIdAttribute(long chipClusterPtr, + ExtendedPanIdAttributeCallback callback + ); + private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, + ExtendedPanIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMeshLocalPrefixAttribute(long chipClusterPtr, + MeshLocalPrefixAttributeCallback callback + ); + private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, + MeshLocalPrefixAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNeighborTableAttribute(long chipClusterPtr, + NeighborTableAttributeCallback callback + ); + private native void subscribeNeighborTableAttribute(long chipClusterPtr, + NeighborTableAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRouteTableAttribute(long chipClusterPtr, + RouteTableAttributeCallback callback + ); + private native void subscribeRouteTableAttribute(long chipClusterPtr, + RouteTableAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPartitionIdAttribute(long chipClusterPtr, + PartitionIdAttributeCallback callback + ); + private native void subscribePartitionIdAttribute(long chipClusterPtr, + PartitionIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWeightingAttribute(long chipClusterPtr, + WeightingAttributeCallback callback + ); + private native void subscribeWeightingAttribute(long chipClusterPtr, + WeightingAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDataVersionAttribute(long chipClusterPtr, + DataVersionAttributeCallback callback + ); + private native void subscribeDataVersionAttribute(long chipClusterPtr, + DataVersionAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readStableDataVersionAttribute(long chipClusterPtr, + StableDataVersionAttributeCallback callback + ); + private native void subscribeStableDataVersionAttribute(long chipClusterPtr, + StableDataVersionAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLeaderRouterIdAttribute(long chipClusterPtr, + LeaderRouterIdAttributeCallback callback + ); + private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, + LeaderRouterIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDetachedRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDetachedRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChildRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChildRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRouterRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRouterRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLeaderRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLeaderRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartitionIdChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePartitionIdChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readParentChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeParentChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxAckedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxAckedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxNoAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxNoAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxRetryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxRetryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrCcaCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrCcaCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrAbortCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrAbortCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrBusyChannelCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrBusyChannelCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxAddressFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxAddressFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDestAddrFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDestAddrFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDuplicatedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDuplicatedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrNoFrameCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrNoFrameCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrUnknownNeighborCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrUnknownNeighborCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrSecCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrSecCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrFcsCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrFcsCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveTimestampAttribute(long chipClusterPtr, + ActiveTimestampAttributeCallback callback + ); + private native void subscribeActiveTimestampAttribute(long chipClusterPtr, + ActiveTimestampAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPendingTimestampAttribute(long chipClusterPtr, + PendingTimestampAttributeCallback callback + ); + private native void subscribePendingTimestampAttribute(long chipClusterPtr, + PendingTimestampAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDelayAttribute(long chipClusterPtr, + DelayAttributeCallback callback + ); + private native void subscribeDelayAttribute(long chipClusterPtr, + DelayAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readChannelPage0MaskAttribute(long chipClusterPtr, + ChannelPage0MaskAttributeCallback callback + ); + private native void subscribeChannelPage0MaskAttribute(long chipClusterPtr, + ChannelPage0MaskAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveNetworkFaultsListAttribute(long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback + ); + private native void subscribeActiveNetworkFaultsListAttribute(long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000036L; + + public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCounts(DefaultClusterCallback callback + ) { + resetCounts(chipClusterPtr, callback, null); + } + + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface BssidAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SecurityTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface WiFiVersionAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ChannelNumberAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface RssiAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BeaconLostCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BeaconRxCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PacketMulticastRxCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PacketMulticastTxCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PacketUnicastRxCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PacketUnicastTxCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentMaxRateAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OverrunCountAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readBssidAttribute( + BssidAttributeCallback callback + ) { + readBssidAttribute(chipClusterPtr, callback); + } + public void subscribeBssidAttribute( + BssidAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSecurityTypeAttribute( + SecurityTypeAttributeCallback callback + ) { + readSecurityTypeAttribute(chipClusterPtr, callback); + } + public void subscribeSecurityTypeAttribute( + SecurityTypeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWiFiVersionAttribute( + WiFiVersionAttributeCallback callback + ) { + readWiFiVersionAttribute(chipClusterPtr, callback); + } + public void subscribeWiFiVersionAttribute( + WiFiVersionAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChannelNumberAttribute( + ChannelNumberAttributeCallback callback + ) { + readChannelNumberAttribute(chipClusterPtr, callback); + } + public void subscribeChannelNumberAttribute( + ChannelNumberAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRssiAttribute( + RssiAttributeCallback callback + ) { + readRssiAttribute(chipClusterPtr, callback); + } + public void subscribeRssiAttribute( + RssiAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBeaconLostCountAttribute( + BeaconLostCountAttributeCallback callback + ) { + readBeaconLostCountAttribute(chipClusterPtr, callback); + } + public void subscribeBeaconLostCountAttribute( + BeaconLostCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBeaconRxCountAttribute( + BeaconRxCountAttributeCallback callback + ) { + readBeaconRxCountAttribute(chipClusterPtr, callback); + } + public void subscribeBeaconRxCountAttribute( + BeaconRxCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPacketMulticastRxCountAttribute( + PacketMulticastRxCountAttributeCallback callback + ) { + readPacketMulticastRxCountAttribute(chipClusterPtr, callback); + } + public void subscribePacketMulticastRxCountAttribute( + PacketMulticastRxCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPacketMulticastTxCountAttribute( + PacketMulticastTxCountAttributeCallback callback + ) { + readPacketMulticastTxCountAttribute(chipClusterPtr, callback); + } + public void subscribePacketMulticastTxCountAttribute( + PacketMulticastTxCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPacketUnicastRxCountAttribute( + PacketUnicastRxCountAttributeCallback callback + ) { + readPacketUnicastRxCountAttribute(chipClusterPtr, callback); + } + public void subscribePacketUnicastRxCountAttribute( + PacketUnicastRxCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPacketUnicastTxCountAttribute( + PacketUnicastTxCountAttributeCallback callback + ) { + readPacketUnicastTxCountAttribute(chipClusterPtr, callback); + } + public void subscribePacketUnicastTxCountAttribute( + PacketUnicastTxCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentMaxRateAttribute( + CurrentMaxRateAttributeCallback callback + ) { + readCurrentMaxRateAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentMaxRateAttribute( + CurrentMaxRateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOverrunCountAttribute( + OverrunCountAttributeCallback callback + ) { + readOverrunCountAttribute(chipClusterPtr, callback); + } + public void subscribeOverrunCountAttribute( + OverrunCountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readBssidAttribute(long chipClusterPtr, + BssidAttributeCallback callback + ); + private native void subscribeBssidAttribute(long chipClusterPtr, + BssidAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSecurityTypeAttribute(long chipClusterPtr, + SecurityTypeAttributeCallback callback + ); + private native void subscribeSecurityTypeAttribute(long chipClusterPtr, + SecurityTypeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWiFiVersionAttribute(long chipClusterPtr, + WiFiVersionAttributeCallback callback + ); + private native void subscribeWiFiVersionAttribute(long chipClusterPtr, + WiFiVersionAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readChannelNumberAttribute(long chipClusterPtr, + ChannelNumberAttributeCallback callback + ); + private native void subscribeChannelNumberAttribute(long chipClusterPtr, + ChannelNumberAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRssiAttribute(long chipClusterPtr, + RssiAttributeCallback callback + ); + private native void subscribeRssiAttribute(long chipClusterPtr, + RssiAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBeaconLostCountAttribute(long chipClusterPtr, + BeaconLostCountAttributeCallback callback + ); + private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, + BeaconLostCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBeaconRxCountAttribute(long chipClusterPtr, + BeaconRxCountAttributeCallback callback + ); + private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, + BeaconRxCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, + PacketMulticastRxCountAttributeCallback callback + ); + private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, + PacketMulticastRxCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, + PacketMulticastTxCountAttributeCallback callback + ); + private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, + PacketMulticastTxCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, + PacketUnicastRxCountAttributeCallback callback + ); + private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, + PacketUnicastRxCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, + PacketUnicastTxCountAttributeCallback callback + ); + private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, + PacketUnicastTxCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentMaxRateAttribute(long chipClusterPtr, + CurrentMaxRateAttributeCallback callback + ); + private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, + CurrentMaxRateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + OverrunCountAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + OverrunCountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000037L; + + public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCounts(DefaultClusterCallback callback + ) { + resetCounts(chipClusterPtr, callback, null); + } + + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface PHYRateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface FullDuplexAttributeCallback { + void onSuccess(@Nullable Boolean value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CarrierDetectAttributeCallback { + void onSuccess(@Nullable Boolean value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readPHYRateAttribute( + PHYRateAttributeCallback callback + ) { + readPHYRateAttribute(chipClusterPtr, callback); + } + public void subscribePHYRateAttribute( + PHYRateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFullDuplexAttribute( + FullDuplexAttributeCallback callback + ) { + readFullDuplexAttribute(chipClusterPtr, callback); + } + public void subscribeFullDuplexAttribute( + FullDuplexAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPacketRxCountAttribute( + LongAttributeCallback callback + ) { + readPacketRxCountAttribute(chipClusterPtr, callback); + } + public void subscribePacketRxCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPacketTxCountAttribute( + LongAttributeCallback callback + ) { + readPacketTxCountAttribute(chipClusterPtr, callback); + } + public void subscribePacketTxCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTxErrCountAttribute( + LongAttributeCallback callback + ) { + readTxErrCountAttribute(chipClusterPtr, callback); + } + public void subscribeTxErrCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCollisionCountAttribute( + LongAttributeCallback callback + ) { + readCollisionCountAttribute(chipClusterPtr, callback); + } + public void subscribeCollisionCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { + readOverrunCountAttribute(chipClusterPtr, callback); + } + public void subscribeOverrunCountAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCarrierDetectAttribute( + CarrierDetectAttributeCallback callback + ) { + readCarrierDetectAttribute(chipClusterPtr, callback); + } + public void subscribeCarrierDetectAttribute( + CarrierDetectAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTimeSinceResetAttribute( + LongAttributeCallback callback + ) { + readTimeSinceResetAttribute(chipClusterPtr, callback); + } + public void subscribeTimeSinceResetAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readPHYRateAttribute(long chipClusterPtr, + PHYRateAttributeCallback callback + ); + private native void subscribePHYRateAttribute(long chipClusterPtr, + PHYRateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFullDuplexAttribute(long chipClusterPtr, + FullDuplexAttributeCallback callback + ); + private native void subscribeFullDuplexAttribute(long chipClusterPtr, + FullDuplexAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPacketRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCollisionCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCollisionCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCarrierDetectAttribute(long chipClusterPtr, + CarrierDetectAttributeCallback callback + ); + private native void subscribeCarrierDetectAttribute(long chipClusterPtr, + CarrierDetectAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTimeSinceResetAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTimeSinceResetAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class TimeSynchronizationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000038L; + + public TimeSynchronizationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void setUTCTime(DefaultClusterCallback callback + , Long UTCTime, Integer granularity, Optional timeSource) { + setUTCTime(chipClusterPtr, callback, UTCTime, granularity, timeSource, null); + } + + public void setUTCTime(DefaultClusterCallback callback + , Long UTCTime, Integer granularity, Optional timeSource + , int timedInvokeTimeoutMs) { + setUTCTime(chipClusterPtr, callback, UTCTime, granularity, timeSource, timedInvokeTimeoutMs); + } + + public void setTrustedTimeSource(DefaultClusterCallback callback + , @Nullable ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct trustedTimeSource) { + setTrustedTimeSource(chipClusterPtr, callback, trustedTimeSource, null); + } + + public void setTrustedTimeSource(DefaultClusterCallback callback + , @Nullable ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct trustedTimeSource + , int timedInvokeTimeoutMs) { + setTrustedTimeSource(chipClusterPtr, callback, trustedTimeSource, timedInvokeTimeoutMs); + } + + public void setTimeZone(SetTimeZoneResponseCallback callback + , ArrayList timeZone) { + setTimeZone(chipClusterPtr, callback, timeZone, null); + } + + public void setTimeZone(SetTimeZoneResponseCallback callback + , ArrayList timeZone + , int timedInvokeTimeoutMs) { + setTimeZone(chipClusterPtr, callback, timeZone, timedInvokeTimeoutMs); + } + + public void setDSTOffset(DefaultClusterCallback callback + , ArrayList DSTOffset) { + setDSTOffset(chipClusterPtr, callback, DSTOffset, null); + } + + public void setDSTOffset(DefaultClusterCallback callback + , ArrayList DSTOffset + , int timedInvokeTimeoutMs) { + setDSTOffset(chipClusterPtr, callback, DSTOffset, timedInvokeTimeoutMs); + } + + public void setDefaultNTP(DefaultClusterCallback callback + , @Nullable String defaultNTP) { + setDefaultNTP(chipClusterPtr, callback, defaultNTP, null); + } + + public void setDefaultNTP(DefaultClusterCallback callback + , @Nullable String defaultNTP + , int timedInvokeTimeoutMs) { + setDefaultNTP(chipClusterPtr, callback, defaultNTP, timedInvokeTimeoutMs); + } + private native void setUTCTime(long chipClusterPtr, DefaultClusterCallback Callback + , Long UTCTime, Integer granularity, Optional timeSource + , @Nullable Integer timedInvokeTimeoutMs); + private native void setTrustedTimeSource(long chipClusterPtr, DefaultClusterCallback Callback + , @Nullable ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct trustedTimeSource + , @Nullable Integer timedInvokeTimeoutMs); + private native void setTimeZone(long chipClusterPtr, SetTimeZoneResponseCallback Callback + , ArrayList timeZone + , @Nullable Integer timedInvokeTimeoutMs); + private native void setDSTOffset(long chipClusterPtr, DefaultClusterCallback Callback + , ArrayList DSTOffset + , @Nullable Integer timedInvokeTimeoutMs); + private native void setDefaultNTP(long chipClusterPtr, DefaultClusterCallback Callback + , @Nullable String defaultNTP + , @Nullable Integer timedInvokeTimeoutMs); + public interface SetTimeZoneResponseCallback { + void onSuccess(Boolean DSTOffsetRequired); + + void onError(Exception error); + } + + + public interface UTCTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DefaultNTPAttributeCallback { + void onSuccess(@Nullable String value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TimeZoneAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DSTOffsetAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LocalTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readUTCTimeAttribute( + UTCTimeAttributeCallback callback + ) { + readUTCTimeAttribute(chipClusterPtr, callback); + } + public void subscribeUTCTimeAttribute( + UTCTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeUTCTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGranularityAttribute( + IntegerAttributeCallback callback + ) { + readGranularityAttribute(chipClusterPtr, callback); + } + public void subscribeGranularityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeGranularityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTimeSourceAttribute( + IntegerAttributeCallback callback + ) { + readTimeSourceAttribute(chipClusterPtr, callback); + } + public void subscribeTimeSourceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTimeSourceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDefaultNTPAttribute( + DefaultNTPAttributeCallback callback + ) { + readDefaultNTPAttribute(chipClusterPtr, callback); + } + public void subscribeDefaultNTPAttribute( + DefaultNTPAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDefaultNTPAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTimeZoneAttribute( + TimeZoneAttributeCallback callback + ) { + readTimeZoneAttribute(chipClusterPtr, callback); + } + public void subscribeTimeZoneAttribute( + TimeZoneAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTimeZoneAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDSTOffsetAttribute( + DSTOffsetAttributeCallback callback + ) { + readDSTOffsetAttribute(chipClusterPtr, callback); + } + public void subscribeDSTOffsetAttribute( + DSTOffsetAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDSTOffsetAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLocalTimeAttribute( + LocalTimeAttributeCallback callback + ) { + readLocalTimeAttribute(chipClusterPtr, callback); + } + public void subscribeLocalTimeAttribute( + LocalTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLocalTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTimeZoneDatabaseAttribute( + IntegerAttributeCallback callback + ) { + readTimeZoneDatabaseAttribute(chipClusterPtr, callback); + } + public void subscribeTimeZoneDatabaseAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTimeZoneDatabaseAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNTPServerAvailableAttribute( + BooleanAttributeCallback callback + ) { + readNTPServerAvailableAttribute(chipClusterPtr, callback); + } + public void subscribeNTPServerAvailableAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNTPServerAvailableAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTimeZoneListMaxSizeAttribute( + IntegerAttributeCallback callback + ) { + readTimeZoneListMaxSizeAttribute(chipClusterPtr, callback); + } + public void subscribeTimeZoneListMaxSizeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTimeZoneListMaxSizeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDSTOffsetListMaxSizeAttribute( + IntegerAttributeCallback callback + ) { + readDSTOffsetListMaxSizeAttribute(chipClusterPtr, callback); + } + public void subscribeDSTOffsetListMaxSizeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDSTOffsetListMaxSizeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportsDNSResolveAttribute( + BooleanAttributeCallback callback + ) { + readSupportsDNSResolveAttribute(chipClusterPtr, callback); + } + public void subscribeSupportsDNSResolveAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportsDNSResolveAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readUTCTimeAttribute(long chipClusterPtr, + UTCTimeAttributeCallback callback + ); + private native void subscribeUTCTimeAttribute(long chipClusterPtr, + UTCTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGranularityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeGranularityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTimeSourceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTimeSourceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDefaultNTPAttribute(long chipClusterPtr, + DefaultNTPAttributeCallback callback + ); + private native void subscribeDefaultNTPAttribute(long chipClusterPtr, + DefaultNTPAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTimeZoneAttribute(long chipClusterPtr, + TimeZoneAttributeCallback callback + ); + private native void subscribeTimeZoneAttribute(long chipClusterPtr, + TimeZoneAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDSTOffsetAttribute(long chipClusterPtr, + DSTOffsetAttributeCallback callback + ); + private native void subscribeDSTOffsetAttribute(long chipClusterPtr, + DSTOffsetAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLocalTimeAttribute(long chipClusterPtr, + LocalTimeAttributeCallback callback + ); + private native void subscribeLocalTimeAttribute(long chipClusterPtr, + LocalTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTimeZoneDatabaseAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTimeZoneDatabaseAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNTPServerAvailableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeNTPServerAvailableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTimeZoneListMaxSizeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTimeZoneListMaxSizeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDSTOffsetListMaxSizeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDSTOffsetListMaxSizeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportsDNSResolveAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeSupportsDNSResolveAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BridgedDeviceBasicInformationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000039L; + + public BridgedDeviceBasicInformationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { + readVendorNameAttribute(chipClusterPtr, callback); + } + public void subscribeVendorNameAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readVendorIDAttribute( + IntegerAttributeCallback callback + ) { + readVendorIDAttribute(chipClusterPtr, callback); + } + public void subscribeVendorIDAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductNameAttribute( + CharStringAttributeCallback callback + ) { + readProductNameAttribute(chipClusterPtr, callback); + } + public void subscribeProductNameAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNodeLabelAttribute( + CharStringAttributeCallback callback + ) { + readNodeLabelAttribute(chipClusterPtr, callback); + } + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { + writeNodeLabelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNodeLabelAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHardwareVersionAttribute( + IntegerAttributeCallback callback + ) { + readHardwareVersionAttribute(chipClusterPtr, callback); + } + public void subscribeHardwareVersionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHardwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { + readHardwareVersionStringAttribute(chipClusterPtr, callback); + } + public void subscribeHardwareVersionStringAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSoftwareVersionAttribute( + LongAttributeCallback callback + ) { + readSoftwareVersionAttribute(chipClusterPtr, callback); + } + public void subscribeSoftwareVersionAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSoftwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { + readSoftwareVersionStringAttribute(chipClusterPtr, callback); + } + public void subscribeSoftwareVersionStringAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readManufacturingDateAttribute( + CharStringAttributeCallback callback + ) { + readManufacturingDateAttribute(chipClusterPtr, callback); + } + public void subscribeManufacturingDateAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPartNumberAttribute( + CharStringAttributeCallback callback + ) { + readPartNumberAttribute(chipClusterPtr, callback); + } + public void subscribePartNumberAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductURLAttribute( + CharStringAttributeCallback callback + ) { + readProductURLAttribute(chipClusterPtr, callback); + } + public void subscribeProductURLAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductLabelAttribute( + CharStringAttributeCallback callback + ) { + readProductLabelAttribute(chipClusterPtr, callback); + } + public void subscribeProductLabelAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSerialNumberAttribute( + CharStringAttributeCallback callback + ) { + readSerialNumberAttribute(chipClusterPtr, callback); + } + public void subscribeSerialNumberAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReachableAttribute( + BooleanAttributeCallback callback + ) { + readReachableAttribute(chipClusterPtr, callback); + } + public void subscribeReachableAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUniqueIDAttribute( + CharStringAttributeCallback callback + ) { + readUniqueIDAttribute(chipClusterPtr, callback); + } + public void subscribeUniqueIDAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeVendorIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribePartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class SwitchCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000003BL; + + public SwitchCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readNumberOfPositionsAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfPositionsAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfPositionsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionAttribute( + IntegerAttributeCallback callback + ) { + readCurrentPositionAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMultiPressMaxAttribute( + IntegerAttributeCallback callback + ) { + readMultiPressMaxAttribute(chipClusterPtr, callback); + } + public void subscribeMultiPressMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readNumberOfPositionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMultiPressMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class AdministratorCommissioningCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000003CL; + + public AdministratorCommissioningCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + + public void openCommissioningWindow(DefaultClusterCallback callback + , Integer commissioningTimeout, byte[] PAKEPasscodeVerifier, Integer discriminator, Long iterations, byte[] salt + , int timedInvokeTimeoutMs) { + openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEPasscodeVerifier, discriminator, iterations, salt, timedInvokeTimeoutMs); + } + + + public void openBasicCommissioningWindow(DefaultClusterCallback callback + , Integer commissioningTimeout + , int timedInvokeTimeoutMs) { + openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + } + + + public void revokeCommissioning(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback + , Integer commissioningTimeout, byte[] PAKEPasscodeVerifier, Integer discriminator, Long iterations, byte[] salt + , @Nullable Integer timedInvokeTimeoutMs); + private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback + , Integer commissioningTimeout + , @Nullable Integer timedInvokeTimeoutMs); + private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AdminFabricIndexAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AdminVendorIdAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readWindowStatusAttribute( + IntegerAttributeCallback callback + ) { + readWindowStatusAttribute(chipClusterPtr, callback); + } + public void subscribeWindowStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAdminFabricIndexAttribute( + AdminFabricIndexAttributeCallback callback + ) { + readAdminFabricIndexAttribute(chipClusterPtr, callback); + } + public void subscribeAdminFabricIndexAttribute( + AdminFabricIndexAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAdminVendorIdAttribute( + AdminVendorIdAttributeCallback callback + ) { + readAdminVendorIdAttribute(chipClusterPtr, callback); + } + public void subscribeAdminVendorIdAttribute( + AdminVendorIdAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readWindowStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWindowStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAdminFabricIndexAttribute(long chipClusterPtr, + AdminFabricIndexAttributeCallback callback + ); + private native void subscribeAdminFabricIndexAttribute(long chipClusterPtr, + AdminFabricIndexAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAdminVendorIdAttribute(long chipClusterPtr, + AdminVendorIdAttributeCallback callback + ); + private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, + AdminVendorIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OperationalCredentialsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000003EL; + + public OperationalCredentialsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void attestationRequest(AttestationResponseCallback callback + , byte[] attestationNonce) { + attestationRequest(chipClusterPtr, callback, attestationNonce, null); + } + + public void attestationRequest(AttestationResponseCallback callback + , byte[] attestationNonce + , int timedInvokeTimeoutMs) { + attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs); + } + + public void certificateChainRequest(CertificateChainResponseCallback callback + , Integer certificateType) { + certificateChainRequest(chipClusterPtr, callback, certificateType, null); + } + + public void certificateChainRequest(CertificateChainResponseCallback callback + , Integer certificateType + , int timedInvokeTimeoutMs) { + certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs); + } + + public void CSRRequest(CSRResponseCallback callback + , byte[] CSRNonce, Optional isForUpdateNOC) { + CSRRequest(chipClusterPtr, callback, CSRNonce, isForUpdateNOC, null); + } + + public void CSRRequest(CSRResponseCallback callback + , byte[] CSRNonce, Optional isForUpdateNOC + , int timedInvokeTimeoutMs) { + CSRRequest(chipClusterPtr, callback, CSRNonce, isForUpdateNOC, timedInvokeTimeoutMs); + } + + public void addNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminSubject, Integer adminVendorId) { + addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminSubject, adminVendorId, null); + } + + public void addNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminSubject, Integer adminVendorId + , int timedInvokeTimeoutMs) { + addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminSubject, adminVendorId, timedInvokeTimeoutMs); + } + + public void updateNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue) { + updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null); + } + + public void updateNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue + , int timedInvokeTimeoutMs) { + updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs); + } + + public void updateFabricLabel(NOCResponseCallback callback + , String label) { + updateFabricLabel(chipClusterPtr, callback, label, null); + } + + public void updateFabricLabel(NOCResponseCallback callback + , String label + , int timedInvokeTimeoutMs) { + updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs); + } + + public void removeFabric(NOCResponseCallback callback + , Integer fabricIndex) { + removeFabric(chipClusterPtr, callback, fabricIndex, null); + } + + public void removeFabric(NOCResponseCallback callback + , Integer fabricIndex + , int timedInvokeTimeoutMs) { + removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback + , byte[] rootCACertificate) { + addTrustedRootCertificate(chipClusterPtr, callback, rootCACertificate, null); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback + , byte[] rootCACertificate + , int timedInvokeTimeoutMs) { + addTrustedRootCertificate(chipClusterPtr, callback, rootCACertificate, timedInvokeTimeoutMs); + } + private native void attestationRequest(long chipClusterPtr, AttestationResponseCallback Callback + , byte[] attestationNonce + , @Nullable Integer timedInvokeTimeoutMs); + private native void certificateChainRequest(long chipClusterPtr, CertificateChainResponseCallback Callback + , Integer certificateType + , @Nullable Integer timedInvokeTimeoutMs); + private native void CSRRequest(long chipClusterPtr, CSRResponseCallback Callback + , byte[] CSRNonce, Optional isForUpdateNOC + , @Nullable Integer timedInvokeTimeoutMs); + private native void addNOC(long chipClusterPtr, NOCResponseCallback Callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminSubject, Integer adminVendorId + , @Nullable Integer timedInvokeTimeoutMs); + private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback + , byte[] NOCValue, Optional ICACValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback Callback + , String label + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeFabric(long chipClusterPtr, NOCResponseCallback Callback + , Integer fabricIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] rootCACertificate + , @Nullable Integer timedInvokeTimeoutMs); + public interface AttestationResponseCallback { + void onSuccess(byte[] attestationElements, byte[] attestationSignature); + + void onError(Exception error); + } + + public interface CertificateChainResponseCallback { + void onSuccess(byte[] certificate); + + void onError(Exception error); + } + + public interface CSRResponseCallback { + void onSuccess(byte[] NOCSRElements, byte[] attestationSignature); + + void onError(Exception error); + } + + public interface NOCResponseCallback { + void onSuccess(Integer statusCode, Optional fabricIndex, Optional debugText); + + void onError(Exception error); + } + + + public interface NOCsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface FabricsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TrustedRootCertificatesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readNOCsAttribute( + NOCsAttributeCallback callback + ) { + readNOCsAttribute(chipClusterPtr, callback, true); + } + public void readNOCsAttributeWithFabricFilter( + NOCsAttributeCallback callback + , + boolean isFabricFiltered + ) { + readNOCsAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void subscribeNOCsAttribute( + NOCsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFabricsAttribute( + FabricsAttributeCallback callback + ) { + readFabricsAttribute(chipClusterPtr, callback, true); + } + public void readFabricsAttributeWithFabricFilter( + FabricsAttributeCallback callback + , + boolean isFabricFiltered + ) { + readFabricsAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void subscribeFabricsAttribute( + FabricsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedFabricsAttribute( + IntegerAttributeCallback callback + ) { + readSupportedFabricsAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedFabricsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCommissionedFabricsAttribute( + IntegerAttributeCallback callback + ) { + readCommissionedFabricsAttribute(chipClusterPtr, callback); + } + public void subscribeCommissionedFabricsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTrustedRootCertificatesAttribute( + TrustedRootCertificatesAttributeCallback callback + ) { + readTrustedRootCertificatesAttribute(chipClusterPtr, callback); + } + public void subscribeTrustedRootCertificatesAttribute( + TrustedRootCertificatesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentFabricIndexAttribute( + IntegerAttributeCallback callback + ) { + readCurrentFabricIndexAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentFabricIndexAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readNOCsAttribute(long chipClusterPtr, + NOCsAttributeCallback callback + , boolean isFabricFiltered + ); + private native void subscribeNOCsAttribute(long chipClusterPtr, + NOCsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFabricsAttribute(long chipClusterPtr, + FabricsAttributeCallback callback + , boolean isFabricFiltered + ); + private native void subscribeFabricsAttribute(long chipClusterPtr, + FabricsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSupportedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCommissionedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCommissionedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTrustedRootCertificatesAttribute(long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback + ); + private native void subscribeTrustedRootCertificatesAttribute(long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentFabricIndexAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class GroupKeyManagementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000003FL; + + public GroupKeyManagementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void keySetWrite(DefaultClusterCallback callback + , ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet) { + keySetWrite(chipClusterPtr, callback, groupKeySet, null); + } + + public void keySetWrite(DefaultClusterCallback callback + , ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet + , int timedInvokeTimeoutMs) { + keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs); + } + + public void keySetRead(KeySetReadResponseCallback callback + , Integer groupKeySetID) { + keySetRead(chipClusterPtr, callback, groupKeySetID, null); + } + + public void keySetRead(KeySetReadResponseCallback callback + , Integer groupKeySetID + , int timedInvokeTimeoutMs) { + keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); + } + + public void keySetRemove(DefaultClusterCallback callback + , Integer groupKeySetID) { + keySetRemove(chipClusterPtr, callback, groupKeySetID, null); + } + + public void keySetRemove(DefaultClusterCallback callback + , Integer groupKeySetID + , int timedInvokeTimeoutMs) { + keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); + } + + public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback + ) { + keySetReadAllIndices(chipClusterPtr, callback, null); + } + + public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback + + , int timedInvokeTimeoutMs) { + keySetReadAllIndices(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Callback + , ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback Callback + , Integer groupKeySetID + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupKeySetID + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface KeySetReadResponseCallback { + void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet); + + void onError(Exception error); + } + + public interface KeySetReadAllIndicesResponseCallback { + void onSuccess(ArrayList groupKeySetIDs); + + void onError(Exception error); + } + + + public interface GroupKeyMapAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GroupTableAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGroupKeyMapAttribute( + GroupKeyMapAttributeCallback callback + ) { + readGroupKeyMapAttribute(chipClusterPtr, callback, true); + } + public void readGroupKeyMapAttributeWithFabricFilter( + GroupKeyMapAttributeCallback callback + , + boolean isFabricFiltered + ) { + readGroupKeyMapAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void writeGroupKeyMapAttribute(DefaultClusterCallback callback, ArrayList value) { + writeGroupKeyMapAttribute(chipClusterPtr, callback, value, null); + } + + public void writeGroupKeyMapAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeGroupKeyMapAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeGroupKeyMapAttribute( + GroupKeyMapAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGroupTableAttribute( + GroupTableAttributeCallback callback + ) { + readGroupTableAttribute(chipClusterPtr, callback, true); + } + public void readGroupTableAttributeWithFabricFilter( + GroupTableAttributeCallback callback + , + boolean isFabricFiltered + ) { + readGroupTableAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void subscribeGroupTableAttribute( + GroupTableAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxGroupsPerFabricAttribute( + IntegerAttributeCallback callback + ) { + readMaxGroupsPerFabricAttribute(chipClusterPtr, callback); + } + public void subscribeMaxGroupsPerFabricAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxGroupKeysPerFabricAttribute( + IntegerAttributeCallback callback + ) { + readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback); + } + public void subscribeMaxGroupKeysPerFabricAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGroupKeyMapAttribute(long chipClusterPtr, + GroupKeyMapAttributeCallback callback + , boolean isFabricFiltered + ); + + private native void writeGroupKeyMapAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, + GroupKeyMapAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGroupTableAttribute(long chipClusterPtr, + GroupTableAttributeCallback callback + , boolean isFabricFiltered + ); + private native void subscribeGroupTableAttribute(long chipClusterPtr, + GroupTableAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxGroupsPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxGroupsPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxGroupKeysPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class FixedLabelCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000040L; + + public FixedLabelCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface LabelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readLabelListAttribute( + LabelListAttributeCallback callback + ) { + readLabelListAttribute(chipClusterPtr, callback); + } + public void subscribeLabelListAttribute( + LabelListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + ); + private native void subscribeLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class UserLabelCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000041L; + + public UserLabelCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface LabelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readLabelListAttribute( + LabelListAttributeCallback callback + ) { + readLabelListAttribute(chipClusterPtr, callback); + } + public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value) { + writeLabelListAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLabelListAttribute( + LabelListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + ); + + private native void writeLabelListAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ProxyConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000042L; + + public ProxyConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ProxyDiscoveryCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000043L; + + public ProxyDiscoveryCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ProxyValidCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000044L; + + public ProxyValidCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BooleanStateCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000045L; + + public BooleanStateCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readStateValueAttribute( + BooleanAttributeCallback callback + ) { + readStateValueAttribute(chipClusterPtr, callback); + } + public void subscribeStateValueAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readStateValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeStateValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class IcdManagementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000046L; + + public IcdManagementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void registerClient(RegisterClientResponseCallback callback + , Long checkInNodeID, Long monitoredSubject, byte[] key, Optional verificationKey) { + registerClient(chipClusterPtr, callback, checkInNodeID, monitoredSubject, key, verificationKey, null); + } + + public void registerClient(RegisterClientResponseCallback callback + , Long checkInNodeID, Long monitoredSubject, byte[] key, Optional verificationKey + , int timedInvokeTimeoutMs) { + registerClient(chipClusterPtr, callback, checkInNodeID, monitoredSubject, key, verificationKey, timedInvokeTimeoutMs); + } + + public void unregisterClient(DefaultClusterCallback callback + , Long checkInNodeID, Optional verificationKey) { + unregisterClient(chipClusterPtr, callback, checkInNodeID, verificationKey, null); + } + + public void unregisterClient(DefaultClusterCallback callback + , Long checkInNodeID, Optional verificationKey + , int timedInvokeTimeoutMs) { + unregisterClient(chipClusterPtr, callback, checkInNodeID, verificationKey, timedInvokeTimeoutMs); + } + + public void stayActiveRequest(DefaultClusterCallback callback + ) { + stayActiveRequest(chipClusterPtr, callback, null); + } + + public void stayActiveRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + stayActiveRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void registerClient(long chipClusterPtr, RegisterClientResponseCallback Callback + , Long checkInNodeID, Long monitoredSubject, byte[] key, Optional verificationKey + , @Nullable Integer timedInvokeTimeoutMs); + private native void unregisterClient(long chipClusterPtr, DefaultClusterCallback Callback + , Long checkInNodeID, Optional verificationKey + , @Nullable Integer timedInvokeTimeoutMs); + private native void stayActiveRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface RegisterClientResponseCallback { + void onSuccess(Long ICDCounter); + + void onError(Exception error); + } + + + public interface RegisteredClientsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readIdleModeIntervalAttribute( + LongAttributeCallback callback + ) { + readIdleModeIntervalAttribute(chipClusterPtr, callback); + } + public void subscribeIdleModeIntervalAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeIdleModeIntervalAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveModeIntervalAttribute( + LongAttributeCallback callback + ) { + readActiveModeIntervalAttribute(chipClusterPtr, callback); + } + public void subscribeActiveModeIntervalAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveModeIntervalAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveModeThresholdAttribute( + IntegerAttributeCallback callback + ) { + readActiveModeThresholdAttribute(chipClusterPtr, callback); + } + public void subscribeActiveModeThresholdAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveModeThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRegisteredClientsAttribute( + RegisteredClientsAttributeCallback callback + ) { + readRegisteredClientsAttribute(chipClusterPtr, callback, true); + } + public void readRegisteredClientsAttributeWithFabricFilter( + RegisteredClientsAttributeCallback callback + , + boolean isFabricFiltered + ) { + readRegisteredClientsAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void subscribeRegisteredClientsAttribute( + RegisteredClientsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeRegisteredClientsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readICDCounterAttribute( + LongAttributeCallback callback + ) { + readICDCounterAttribute(chipClusterPtr, callback); + } + public void subscribeICDCounterAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeICDCounterAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClientsSupportedPerFabricAttribute( + IntegerAttributeCallback callback + ) { + readClientsSupportedPerFabricAttribute(chipClusterPtr, callback); + } + public void subscribeClientsSupportedPerFabricAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClientsSupportedPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readIdleModeIntervalAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeIdleModeIntervalAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveModeIntervalAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeActiveModeIntervalAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveModeThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActiveModeThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRegisteredClientsAttribute(long chipClusterPtr, + RegisteredClientsAttributeCallback callback + , boolean isFabricFiltered + ); + private native void subscribeRegisteredClientsAttribute(long chipClusterPtr, + RegisteredClientsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readICDCounterAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeICDCounterAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClientsSupportedPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClientsSupportedPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ModeSelectCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000050L; + + public ModeSelectCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeToMode(DefaultClusterCallback callback + , Integer newMode) { + changeToMode(chipClusterPtr, callback, newMode, null); + } + + public void changeToMode(DefaultClusterCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { + changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); + } + private native void changeToMode(long chipClusterPtr, DefaultClusterCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); + + public interface StandardNamespaceAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { + readDescriptionAttribute(chipClusterPtr, callback); + } + public void subscribeDescriptionAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStandardNamespaceAttribute( + StandardNamespaceAttributeCallback callback + ) { + readStandardNamespaceAttribute(chipClusterPtr, callback); + } + public void subscribeStandardNamespaceAttribute( + StandardNamespaceAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStandardNamespaceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { + readSupportedModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedModesAttribute( + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { + readCurrentModeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpModeAttribute( + StartUpModeAttributeCallback callback + ) { + readStartUpModeAttribute(chipClusterPtr, callback); + } + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpModeAttribute( + StartUpModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnModeAttribute( + OnModeAttributeCallback callback + ) { + readOnModeAttribute(chipClusterPtr, callback); + } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnModeAttribute( + OnModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStandardNamespaceAttribute(long chipClusterPtr, + StandardNamespaceAttributeCallback callback + ); + private native void subscribeStandardNamespaceAttribute(long chipClusterPtr, + StandardNamespaceAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + ); + + private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class LaundryWasherModeCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000051L; + + public LaundryWasherModeCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode) { + changeToMode(chipClusterPtr, callback, newMode, null); + } + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { + changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); + } + private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeToModeResponseCallback { + void onSuccess(Integer status, Optional statusText); + + void onError(Exception error); + } + + + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { + readSupportedModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedModesAttribute( + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { + readCurrentModeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpModeAttribute( + StartUpModeAttributeCallback callback + ) { + readStartUpModeAttribute(chipClusterPtr, callback); + } + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpModeAttribute( + StartUpModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnModeAttribute( + OnModeAttributeCallback callback + ) { + readOnModeAttribute(chipClusterPtr, callback); + } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnModeAttribute( + OnModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + ); + + private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RefrigeratorAndTemperatureControlledCabinetModeCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000052L; + + public RefrigeratorAndTemperatureControlledCabinetModeCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode) { + changeToMode(chipClusterPtr, callback, newMode, null); + } + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { + changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); + } + private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeToModeResponseCallback { + void onSuccess(Integer status, Optional statusText); + + void onError(Exception error); + } + + + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { + readSupportedModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedModesAttribute( + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { + readCurrentModeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpModeAttribute( + StartUpModeAttributeCallback callback + ) { + readStartUpModeAttribute(chipClusterPtr, callback); + } + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpModeAttribute( + StartUpModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnModeAttribute( + OnModeAttributeCallback callback + ) { + readOnModeAttribute(chipClusterPtr, callback); + } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnModeAttribute( + OnModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + ); + + private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class LaundryWasherControlsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000053L; + + public LaundryWasherControlsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SpinSpeedsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SpinSpeedCurrentAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SupportedRinsesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSpinSpeedsAttribute( + SpinSpeedsAttributeCallback callback + ) { + readSpinSpeedsAttribute(chipClusterPtr, callback); + } + public void subscribeSpinSpeedsAttribute( + SpinSpeedsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSpinSpeedsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSpinSpeedCurrentAttribute( + SpinSpeedCurrentAttributeCallback callback + ) { + readSpinSpeedCurrentAttribute(chipClusterPtr, callback); + } + public void writeSpinSpeedCurrentAttribute(DefaultClusterCallback callback, Integer value) { + writeSpinSpeedCurrentAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSpinSpeedCurrentAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSpinSpeedCurrentAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSpinSpeedCurrentAttribute( + SpinSpeedCurrentAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSpinSpeedCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfRinsesAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfRinsesAttribute(chipClusterPtr, callback); + } + public void writeNumberOfRinsesAttribute(DefaultClusterCallback callback, Integer value) { + writeNumberOfRinsesAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNumberOfRinsesAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNumberOfRinsesAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNumberOfRinsesAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfRinsesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedRinsesAttribute( + SupportedRinsesAttributeCallback callback + ) { + readSupportedRinsesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedRinsesAttribute( + SupportedRinsesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedRinsesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSpinSpeedsAttribute(long chipClusterPtr, + SpinSpeedsAttributeCallback callback + ); + private native void subscribeSpinSpeedsAttribute(long chipClusterPtr, + SpinSpeedsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSpinSpeedCurrentAttribute(long chipClusterPtr, + SpinSpeedCurrentAttributeCallback callback + ); + + private native void writeSpinSpeedCurrentAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSpinSpeedCurrentAttribute(long chipClusterPtr, + SpinSpeedCurrentAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNumberOfRinsesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeNumberOfRinsesAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNumberOfRinsesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedRinsesAttribute(long chipClusterPtr, + SupportedRinsesAttributeCallback callback + ); + private native void subscribeSupportedRinsesAttribute(long chipClusterPtr, + SupportedRinsesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RvcRunModeCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000054L; + + public RvcRunModeCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode) { + changeToMode(chipClusterPtr, callback, newMode, null); + } + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { + changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); + } + private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeToModeResponseCallback { + void onSuccess(Integer status, Optional statusText); + + void onError(Exception error); + } + + + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { + readSupportedModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedModesAttribute( + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { + readCurrentModeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpModeAttribute( + StartUpModeAttributeCallback callback + ) { + readStartUpModeAttribute(chipClusterPtr, callback); + } + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpModeAttribute( + StartUpModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnModeAttribute( + OnModeAttributeCallback callback + ) { + readOnModeAttribute(chipClusterPtr, callback); + } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnModeAttribute( + OnModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + ); + + private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RvcCleanModeCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000055L; + + public RvcCleanModeCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode) { + changeToMode(chipClusterPtr, callback, newMode, null); + } + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { + changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); + } + private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeToModeResponseCallback { + void onSuccess(Integer status, Optional statusText); + + void onError(Exception error); + } + + + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { + readSupportedModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedModesAttribute( + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { + readCurrentModeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpModeAttribute( + StartUpModeAttributeCallback callback + ) { + readStartUpModeAttribute(chipClusterPtr, callback); + } + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpModeAttribute( + StartUpModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnModeAttribute( + OnModeAttributeCallback callback + ) { + readOnModeAttribute(chipClusterPtr, callback); + } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnModeAttribute( + OnModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + ); + + private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class TemperatureControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000056L; + + public TemperatureControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void setTemperature(DefaultClusterCallback callback + , Optional targetTemperature, Optional targetTemperatureLevel) { + setTemperature(chipClusterPtr, callback, targetTemperature, targetTemperatureLevel, null); + } + + public void setTemperature(DefaultClusterCallback callback + , Optional targetTemperature, Optional targetTemperatureLevel + , int timedInvokeTimeoutMs) { + setTemperature(chipClusterPtr, callback, targetTemperature, targetTemperatureLevel, timedInvokeTimeoutMs); + } + private native void setTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Optional targetTemperature, Optional targetTemperatureLevel + , @Nullable Integer timedInvokeTimeoutMs); + + public interface SupportedTemperatureLevelsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readTemperatureSetpointAttribute( + IntegerAttributeCallback callback + ) { + readTemperatureSetpointAttribute(chipClusterPtr, callback); + } + public void subscribeTemperatureSetpointAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTemperatureSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinTemperatureAttribute( + IntegerAttributeCallback callback + ) { + readMinTemperatureAttribute(chipClusterPtr, callback); + } + public void subscribeMinTemperatureAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxTemperatureAttribute( + IntegerAttributeCallback callback + ) { + readMaxTemperatureAttribute(chipClusterPtr, callback); + } + public void subscribeMaxTemperatureAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStepAttribute( + IntegerAttributeCallback callback + ) { + readStepAttribute(chipClusterPtr, callback); + } + public void subscribeStepAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStepAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSelectedTemperatureLevelAttribute( + IntegerAttributeCallback callback + ) { + readSelectedTemperatureLevelAttribute(chipClusterPtr, callback); + } + public void subscribeSelectedTemperatureLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSelectedTemperatureLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedTemperatureLevelsAttribute( + SupportedTemperatureLevelsAttributeCallback callback + ) { + readSupportedTemperatureLevelsAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedTemperatureLevelsAttribute( + SupportedTemperatureLevelsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedTemperatureLevelsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readTemperatureSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTemperatureSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStepAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStepAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSelectedTemperatureLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSelectedTemperatureLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedTemperatureLevelsAttribute(long chipClusterPtr, + SupportedTemperatureLevelsAttributeCallback callback + ); + private native void subscribeSupportedTemperatureLevelsAttribute(long chipClusterPtr, + SupportedTemperatureLevelsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RefrigeratorAlarmCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000057L; + + public RefrigeratorAlarmCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMaskAttribute( + LongAttributeCallback callback + ) { + readMaskAttribute(chipClusterPtr, callback); + } + public void subscribeMaskAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStateAttribute( + LongAttributeCallback callback + ) { + readStateAttribute(chipClusterPtr, callback); + } + public void subscribeStateAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedAttribute( + LongAttributeCallback callback + ) { + readSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMaskAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeMaskAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStateAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeStateAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSupportedAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class DishwasherModeCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000059L; + + public DishwasherModeCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode) { + changeToMode(chipClusterPtr, callback, newMode, null); + } + + public void changeToMode(ChangeToModeResponseCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { + changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); + } + private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeToModeResponseCallback { + void onSuccess(Integer status, Optional statusText); + + void onError(Exception error); + } + + + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OnModeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { + readSupportedModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedModesAttribute( + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { + readCurrentModeAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpModeAttribute( + StartUpModeAttributeCallback callback + ) { + readStartUpModeAttribute(chipClusterPtr, callback); + } + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpModeAttribute( + StartUpModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOnModeAttribute( + OnModeAttributeCallback callback + ) { + readOnModeAttribute(chipClusterPtr, callback); + } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOnModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOnModeAttribute( + OnModeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + ); + + private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + StartUpModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + OnModeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class AirQualityCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000005BL; + + public AirQualityCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readAirQualityAttribute( + IntegerAttributeCallback callback + ) { + readAirQualityAttribute(chipClusterPtr, callback); + } + public void subscribeAirQualityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAirQualityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readAirQualityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAirQualityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class SmokeCoAlarmCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000005CL; + + public SmokeCoAlarmCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void selfTestRequest(DefaultClusterCallback callback + ) { + selfTestRequest(chipClusterPtr, callback, null); + } + + public void selfTestRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + selfTestRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void selfTestRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readExpressedStateAttribute( + IntegerAttributeCallback callback + ) { + readExpressedStateAttribute(chipClusterPtr, callback); + } + public void subscribeExpressedStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeExpressedStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSmokeStateAttribute( + IntegerAttributeCallback callback + ) { + readSmokeStateAttribute(chipClusterPtr, callback); + } + public void subscribeSmokeStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSmokeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCOStateAttribute( + IntegerAttributeCallback callback + ) { + readCOStateAttribute(chipClusterPtr, callback); + } + public void subscribeCOStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCOStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBatteryAlertAttribute( + IntegerAttributeCallback callback + ) { + readBatteryAlertAttribute(chipClusterPtr, callback); + } + public void subscribeBatteryAlertAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBatteryAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDeviceMutedAttribute( + IntegerAttributeCallback callback + ) { + readDeviceMutedAttribute(chipClusterPtr, callback); + } + public void subscribeDeviceMutedAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDeviceMutedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTestInProgressAttribute( + BooleanAttributeCallback callback + ) { + readTestInProgressAttribute(chipClusterPtr, callback); + } + public void subscribeTestInProgressAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTestInProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHardwareFaultAlertAttribute( + BooleanAttributeCallback callback + ) { + readHardwareFaultAlertAttribute(chipClusterPtr, callback); + } + public void subscribeHardwareFaultAlertAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHardwareFaultAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEndOfServiceAlertAttribute( + IntegerAttributeCallback callback + ) { + readEndOfServiceAlertAttribute(chipClusterPtr, callback); + } + public void subscribeEndOfServiceAlertAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEndOfServiceAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInterconnectSmokeAlarmAttribute( + IntegerAttributeCallback callback + ) { + readInterconnectSmokeAlarmAttribute(chipClusterPtr, callback); + } + public void subscribeInterconnectSmokeAlarmAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInterconnectSmokeAlarmAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInterconnectCOAlarmAttribute( + IntegerAttributeCallback callback + ) { + readInterconnectCOAlarmAttribute(chipClusterPtr, callback); + } + public void subscribeInterconnectCOAlarmAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInterconnectCOAlarmAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readContaminationStateAttribute( + IntegerAttributeCallback callback + ) { + readContaminationStateAttribute(chipClusterPtr, callback); + } + public void subscribeContaminationStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeContaminationStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSmokeSensitivityLevelAttribute( + IntegerAttributeCallback callback + ) { + readSmokeSensitivityLevelAttribute(chipClusterPtr, callback); + } + public void writeSmokeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeSmokeSensitivityLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSmokeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSmokeSensitivityLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSmokeSensitivityLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSmokeSensitivityLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readExpiryDateAttribute( + LongAttributeCallback callback + ) { + readExpiryDateAttribute(chipClusterPtr, callback); + } + public void subscribeExpiryDateAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeExpiryDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readExpressedStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeExpressedStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSmokeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSmokeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCOStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCOStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryAlertAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryAlertAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDeviceMutedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDeviceMutedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTestInProgressAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeTestInProgressAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareFaultAlertAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeHardwareFaultAlertAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEndOfServiceAlertAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEndOfServiceAlertAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInterconnectSmokeAlarmAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInterconnectSmokeAlarmAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInterconnectCOAlarmAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInterconnectCOAlarmAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readContaminationStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeContaminationStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSmokeSensitivityLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSmokeSensitivityLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSmokeSensitivityLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readExpiryDateAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeExpiryDateAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class DishwasherAlarmCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000005DL; + + public DishwasherAlarmCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void reset(DefaultClusterCallback callback + , Long alarms) { + reset(chipClusterPtr, callback, alarms, null); + } + + public void reset(DefaultClusterCallback callback + , Long alarms + , int timedInvokeTimeoutMs) { + reset(chipClusterPtr, callback, alarms, timedInvokeTimeoutMs); + } + + public void modifyEnabledAlarms(DefaultClusterCallback callback + , Long mask) { + modifyEnabledAlarms(chipClusterPtr, callback, mask, null); + } + + public void modifyEnabledAlarms(DefaultClusterCallback callback + , Long mask + , int timedInvokeTimeoutMs) { + modifyEnabledAlarms(chipClusterPtr, callback, mask, timedInvokeTimeoutMs); + } + private native void reset(long chipClusterPtr, DefaultClusterCallback Callback + , Long alarms + , @Nullable Integer timedInvokeTimeoutMs); + private native void modifyEnabledAlarms(long chipClusterPtr, DefaultClusterCallback Callback + , Long mask + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMaskAttribute( + LongAttributeCallback callback + ) { + readMaskAttribute(chipClusterPtr, callback); + } + public void subscribeMaskAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLatchAttribute( + LongAttributeCallback callback + ) { + readLatchAttribute(chipClusterPtr, callback); + } + public void subscribeLatchAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLatchAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStateAttribute( + LongAttributeCallback callback + ) { + readStateAttribute(chipClusterPtr, callback); + } + public void subscribeStateAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedAttribute( + LongAttributeCallback callback + ) { + readSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMaskAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeMaskAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLatchAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeLatchAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStateAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeStateAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSupportedAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OperationalStateCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000060L; + + public OperationalStateCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void pause(OperationalCommandResponseCallback callback + ) { + pause(chipClusterPtr, callback, null); + } + + public void pause(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + pause(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void stop(OperationalCommandResponseCallback callback + ) { + stop(chipClusterPtr, callback, null); + } + + public void stop(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void start(OperationalCommandResponseCallback callback + ) { + start(chipClusterPtr, callback, null); + } + + public void start(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + start(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void resume(OperationalCommandResponseCallback callback + ) { + resume(chipClusterPtr, callback, null); + } + + public void resume(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + resume(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void pause(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void stop(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void start(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void resume(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface OperationalCommandResponseCallback { + void onSuccess(ChipStructs.OperationalStateClusterErrorStateStruct commandResponseState); + + void onError(Exception error); + } + + + public interface PhaseListAttributeCallback { + void onSuccess(@Nullable List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPhaseAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CountdownTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OperationalStateListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readPhaseListAttribute( + PhaseListAttributeCallback callback + ) { + readPhaseListAttribute(chipClusterPtr, callback); + } + public void subscribePhaseListAttribute( + PhaseListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePhaseListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPhaseAttribute( + CurrentPhaseAttributeCallback callback + ) { + readCurrentPhaseAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPhaseAttribute( + CurrentPhaseAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPhaseAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCountdownTimeAttribute( + CountdownTimeAttributeCallback callback + ) { + readCountdownTimeAttribute(chipClusterPtr, callback); + } + public void subscribeCountdownTimeAttribute( + CountdownTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCountdownTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalStateListAttribute( + OperationalStateListAttributeCallback callback + ) { + readOperationalStateListAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalStateListAttribute( + OperationalStateListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOperationalStateListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalStateAttribute( + IntegerAttributeCallback callback + ) { + readOperationalStateAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOperationalStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readPhaseListAttribute(long chipClusterPtr, + PhaseListAttributeCallback callback + ); + private native void subscribePhaseListAttribute(long chipClusterPtr, + PhaseListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPhaseAttribute(long chipClusterPtr, + CurrentPhaseAttributeCallback callback + ); + private native void subscribeCurrentPhaseAttribute(long chipClusterPtr, + CurrentPhaseAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCountdownTimeAttribute(long chipClusterPtr, + CountdownTimeAttributeCallback callback + ); + private native void subscribeCountdownTimeAttribute(long chipClusterPtr, + CountdownTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStateListAttribute(long chipClusterPtr, + OperationalStateListAttributeCallback callback + ); + private native void subscribeOperationalStateListAttribute(long chipClusterPtr, + OperationalStateListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOperationalStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RvcOperationalStateCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000061L; + + public RvcOperationalStateCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void pause(OperationalCommandResponseCallback callback + ) { + pause(chipClusterPtr, callback, null); + } + + public void pause(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + pause(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void stop(OperationalCommandResponseCallback callback + ) { + stop(chipClusterPtr, callback, null); + } + + public void stop(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void start(OperationalCommandResponseCallback callback + ) { + start(chipClusterPtr, callback, null); + } + + public void start(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + start(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void resume(OperationalCommandResponseCallback callback + ) { + resume(chipClusterPtr, callback, null); + } + + public void resume(OperationalCommandResponseCallback callback + + , int timedInvokeTimeoutMs) { + resume(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void pause(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void stop(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void start(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void resume(long chipClusterPtr, OperationalCommandResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface OperationalCommandResponseCallback { + void onSuccess(ChipStructs.RvcOperationalStateClusterErrorStateStruct commandResponseState); + + void onError(Exception error); + } + + + public interface PhaseListAttributeCallback { + void onSuccess(@Nullable List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPhaseAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CountdownTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OperationalStateListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readPhaseListAttribute( + PhaseListAttributeCallback callback + ) { + readPhaseListAttribute(chipClusterPtr, callback); + } + public void subscribePhaseListAttribute( + PhaseListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePhaseListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPhaseAttribute( + CurrentPhaseAttributeCallback callback + ) { + readCurrentPhaseAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPhaseAttribute( + CurrentPhaseAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPhaseAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCountdownTimeAttribute( + CountdownTimeAttributeCallback callback + ) { + readCountdownTimeAttribute(chipClusterPtr, callback); + } + public void subscribeCountdownTimeAttribute( + CountdownTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCountdownTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalStateListAttribute( + OperationalStateListAttributeCallback callback + ) { + readOperationalStateListAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalStateListAttribute( + OperationalStateListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOperationalStateListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalStateAttribute( + IntegerAttributeCallback callback + ) { + readOperationalStateAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOperationalStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readPhaseListAttribute(long chipClusterPtr, + PhaseListAttributeCallback callback + ); + private native void subscribePhaseListAttribute(long chipClusterPtr, + PhaseListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPhaseAttribute(long chipClusterPtr, + CurrentPhaseAttributeCallback callback + ); + private native void subscribeCurrentPhaseAttribute(long chipClusterPtr, + CurrentPhaseAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCountdownTimeAttribute(long chipClusterPtr, + CountdownTimeAttributeCallback callback + ); + private native void subscribeCountdownTimeAttribute(long chipClusterPtr, + CountdownTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStateListAttribute(long chipClusterPtr, + OperationalStateListAttributeCallback callback + ); + private native void subscribeOperationalStateListAttribute(long chipClusterPtr, + OperationalStateListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOperationalStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class HepaFilterMonitoringCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000071L; + + public HepaFilterMonitoringCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCondition(DefaultClusterCallback callback + ) { + resetCondition(chipClusterPtr, callback, null); + } + + public void resetCondition(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCondition(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void resetCondition(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface LastChangedTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ReplacementProductListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readConditionAttribute( + IntegerAttributeCallback callback + ) { + readConditionAttribute(chipClusterPtr, callback); + } + public void subscribeConditionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeConditionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDegradationDirectionAttribute( + IntegerAttributeCallback callback + ) { + readDegradationDirectionAttribute(chipClusterPtr, callback); + } + public void subscribeDegradationDirectionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDegradationDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChangeIndicationAttribute( + IntegerAttributeCallback callback + ) { + readChangeIndicationAttribute(chipClusterPtr, callback); + } + public void subscribeChangeIndicationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeChangeIndicationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInPlaceIndicatorAttribute( + BooleanAttributeCallback callback + ) { + readInPlaceIndicatorAttribute(chipClusterPtr, callback); + } + public void subscribeInPlaceIndicatorAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInPlaceIndicatorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLastChangedTimeAttribute( + LastChangedTimeAttributeCallback callback + ) { + readLastChangedTimeAttribute(chipClusterPtr, callback); + } + public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value) { + writeLastChangedTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLastChangedTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLastChangedTimeAttribute( + LastChangedTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLastChangedTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReplacementProductListAttribute( + ReplacementProductListAttributeCallback callback + ) { + readReplacementProductListAttribute(chipClusterPtr, callback); + } + public void subscribeReplacementProductListAttribute( + ReplacementProductListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeReplacementProductListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readConditionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConditionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDegradationDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDegradationDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChangeIndicationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChangeIndicationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInPlaceIndicatorAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeInPlaceIndicatorAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastChangedTimeAttribute(long chipClusterPtr, + LastChangedTimeAttributeCallback callback + ); + + private native void writeLastChangedTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLastChangedTimeAttribute(long chipClusterPtr, + LastChangedTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readReplacementProductListAttribute(long chipClusterPtr, + ReplacementProductListAttributeCallback callback + ); + private native void subscribeReplacementProductListAttribute(long chipClusterPtr, + ReplacementProductListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ActivatedCarbonFilterMonitoringCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000072L; + + public ActivatedCarbonFilterMonitoringCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCondition(DefaultClusterCallback callback + ) { + resetCondition(chipClusterPtr, callback, null); + } + + public void resetCondition(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCondition(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void resetCondition(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface LastChangedTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ReplacementProductListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readConditionAttribute( + IntegerAttributeCallback callback + ) { + readConditionAttribute(chipClusterPtr, callback); + } + public void subscribeConditionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeConditionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDegradationDirectionAttribute( + IntegerAttributeCallback callback + ) { + readDegradationDirectionAttribute(chipClusterPtr, callback); + } + public void subscribeDegradationDirectionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDegradationDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChangeIndicationAttribute( + IntegerAttributeCallback callback + ) { + readChangeIndicationAttribute(chipClusterPtr, callback); + } + public void subscribeChangeIndicationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeChangeIndicationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInPlaceIndicatorAttribute( + BooleanAttributeCallback callback + ) { + readInPlaceIndicatorAttribute(chipClusterPtr, callback); + } + public void subscribeInPlaceIndicatorAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInPlaceIndicatorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLastChangedTimeAttribute( + LastChangedTimeAttributeCallback callback + ) { + readLastChangedTimeAttribute(chipClusterPtr, callback); + } + public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value) { + writeLastChangedTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLastChangedTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLastChangedTimeAttribute( + LastChangedTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLastChangedTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReplacementProductListAttribute( + ReplacementProductListAttributeCallback callback + ) { + readReplacementProductListAttribute(chipClusterPtr, callback); + } + public void subscribeReplacementProductListAttribute( + ReplacementProductListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeReplacementProductListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readConditionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConditionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDegradationDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDegradationDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChangeIndicationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChangeIndicationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInPlaceIndicatorAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeInPlaceIndicatorAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastChangedTimeAttribute(long chipClusterPtr, + LastChangedTimeAttributeCallback callback + ); + + private native void writeLastChangedTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLastChangedTimeAttribute(long chipClusterPtr, + LastChangedTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readReplacementProductListAttribute(long chipClusterPtr, + ReplacementProductListAttributeCallback callback + ); + private native void subscribeReplacementProductListAttribute(long chipClusterPtr, + ReplacementProductListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BooleanSensorConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000080L; + + public BooleanSensorConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void supressRequest(DefaultClusterCallback callback + , Integer alarmsToSuppress) { + supressRequest(chipClusterPtr, callback, alarmsToSuppress, null); + } + + public void supressRequest(DefaultClusterCallback callback + , Integer alarmsToSuppress + , int timedInvokeTimeoutMs) { + supressRequest(chipClusterPtr, callback, alarmsToSuppress, timedInvokeTimeoutMs); + } + private native void supressRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer alarmsToSuppress + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readSensitivityLevelAttribute( + IntegerAttributeCallback callback + ) { + readSensitivityLevelAttribute(chipClusterPtr, callback); + } + public void writeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeSensitivityLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSensitivityLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSensitivityLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSensitivityLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAlarmsActiveAttribute( + IntegerAttributeCallback callback + ) { + readAlarmsActiveAttribute(chipClusterPtr, callback); + } + public void subscribeAlarmsActiveAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAlarmsActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAlarmsSuppressedAttribute( + IntegerAttributeCallback callback + ) { + readAlarmsSuppressedAttribute(chipClusterPtr, callback); + } + public void subscribeAlarmsSuppressedAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAlarmsSuppressedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAlarmsEnabledAttribute( + IntegerAttributeCallback callback + ) { + readAlarmsEnabledAttribute(chipClusterPtr, callback); + } + public void writeAlarmsEnabledAttribute(DefaultClusterCallback callback, Integer value) { + writeAlarmsEnabledAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAlarmsEnabledAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeAlarmsEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAlarmsEnabledAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAlarmsEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readSensitivityLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSensitivityLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSensitivityLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAlarmsActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAlarmsActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAlarmsSuppressedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAlarmsSuppressedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAlarmsEnabledAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeAlarmsEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAlarmsEnabledAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ValveConfigurationAndControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000081L; + + public ValveConfigurationAndControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void open(DefaultClusterCallback callback + , Optional openDuration) { + open(chipClusterPtr, callback, openDuration, null); + } + + public void open(DefaultClusterCallback callback + , Optional openDuration + , int timedInvokeTimeoutMs) { + open(chipClusterPtr, callback, openDuration, timedInvokeTimeoutMs); + } + + public void close(DefaultClusterCallback callback + ) { + close(chipClusterPtr, callback, null); + } + + public void close(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + close(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void setLevel(DefaultClusterCallback callback + , Integer level, Optional openDuration) { + setLevel(chipClusterPtr, callback, level, openDuration, null); + } + + public void setLevel(DefaultClusterCallback callback + , Integer level, Optional openDuration + , int timedInvokeTimeoutMs) { + setLevel(chipClusterPtr, callback, level, openDuration, timedInvokeTimeoutMs); + } + private native void open(long chipClusterPtr, DefaultClusterCallback Callback + , Optional openDuration + , @Nullable Integer timedInvokeTimeoutMs); + private native void close(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void setLevel(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, Optional openDuration + , @Nullable Integer timedInvokeTimeoutMs); + + public interface OpenDurationAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AutoCloseTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface RemainingDurationAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TargetStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TargetLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OpenLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readOpenDurationAttribute( + OpenDurationAttributeCallback callback + ) { + readOpenDurationAttribute(chipClusterPtr, callback); + } + public void writeOpenDurationAttribute(DefaultClusterCallback callback, Long value) { + writeOpenDurationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOpenDurationAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeOpenDurationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOpenDurationAttribute( + OpenDurationAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOpenDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAutoCloseTimeAttribute( + AutoCloseTimeAttributeCallback callback + ) { + readAutoCloseTimeAttribute(chipClusterPtr, callback); + } + public void subscribeAutoCloseTimeAttribute( + AutoCloseTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAutoCloseTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRemainingDurationAttribute( + RemainingDurationAttributeCallback callback + ) { + readRemainingDurationAttribute(chipClusterPtr, callback); + } + public void subscribeRemainingDurationAttribute( + RemainingDurationAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeRemainingDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentStateAttribute( + CurrentStateAttributeCallback callback + ) { + readCurrentStateAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentStateAttribute( + CurrentStateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTargetStateAttribute( + TargetStateAttributeCallback callback + ) { + readTargetStateAttribute(chipClusterPtr, callback); + } + public void subscribeTargetStateAttribute( + TargetStateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpStateAttribute( + IntegerAttributeCallback callback + ) { + readStartUpStateAttribute(chipClusterPtr, callback); + } + public void writeStartUpStateAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpStateAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpStateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpStateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStartUpStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentLevelAttribute( + CurrentLevelAttributeCallback callback + ) { + readCurrentLevelAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentLevelAttribute( + CurrentLevelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTargetLevelAttribute( + TargetLevelAttributeCallback callback + ) { + readTargetLevelAttribute(chipClusterPtr, callback); + } + public void subscribeTargetLevelAttribute( + TargetLevelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOpenLevelAttribute( + OpenLevelAttributeCallback callback + ) { + readOpenLevelAttribute(chipClusterPtr, callback); + } + public void writeOpenLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeOpenLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOpenLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOpenLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOpenLevelAttribute( + OpenLevelAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOpenLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readValveFaultAttribute( + IntegerAttributeCallback callback + ) { + readValveFaultAttribute(chipClusterPtr, callback); + } + public void subscribeValveFaultAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeValveFaultAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readOpenDurationAttribute(long chipClusterPtr, + OpenDurationAttributeCallback callback + ); + + private native void writeOpenDurationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOpenDurationAttribute(long chipClusterPtr, + OpenDurationAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAutoCloseTimeAttribute(long chipClusterPtr, + AutoCloseTimeAttributeCallback callback + ); + private native void subscribeAutoCloseTimeAttribute(long chipClusterPtr, + AutoCloseTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRemainingDurationAttribute(long chipClusterPtr, + RemainingDurationAttributeCallback callback + ); + private native void subscribeRemainingDurationAttribute(long chipClusterPtr, + RemainingDurationAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentStateAttribute(long chipClusterPtr, + CurrentStateAttributeCallback callback + ); + private native void subscribeCurrentStateAttribute(long chipClusterPtr, + CurrentStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTargetStateAttribute(long chipClusterPtr, + TargetStateAttributeCallback callback + ); + private native void subscribeTargetStateAttribute(long chipClusterPtr, + TargetStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readStartUpStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeStartUpStateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentLevelAttribute(long chipClusterPtr, + CurrentLevelAttributeCallback callback + ); + private native void subscribeCurrentLevelAttribute(long chipClusterPtr, + CurrentLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTargetLevelAttribute(long chipClusterPtr, + TargetLevelAttributeCallback callback + ); + private native void subscribeTargetLevelAttribute(long chipClusterPtr, + TargetLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOpenLevelAttribute(long chipClusterPtr, + OpenLevelAttributeCallback callback + ); + + private native void writeOpenLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOpenLevelAttribute(long chipClusterPtr, + OpenLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readValveFaultAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeValveFaultAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class DoorLockCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000101L; + + public DoorLockCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + + public void lockDoor(DefaultClusterCallback callback + , Optional PINCode + , int timedInvokeTimeoutMs) { + lockDoor(chipClusterPtr, callback, PINCode, timedInvokeTimeoutMs); + } + + + public void unlockDoor(DefaultClusterCallback callback + , Optional PINCode + , int timedInvokeTimeoutMs) { + unlockDoor(chipClusterPtr, callback, PINCode, timedInvokeTimeoutMs); + } + + + public void unlockWithTimeout(DefaultClusterCallback callback + , Integer timeout, Optional PINCode + , int timedInvokeTimeoutMs) { + unlockWithTimeout(chipClusterPtr, callback, timeout, PINCode, timedInvokeTimeoutMs); + } + + public void setWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) { + setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, null); + } + + public void setWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute + , int timedInvokeTimeoutMs) { + setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, timedInvokeTimeoutMs); + } + + public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback + , Integer weekDayIndex, Integer userIndex) { + getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); + } + + public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback + , Integer weekDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { + getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); + } + + public void clearWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex) { + clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); + } + + public void clearWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { + clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); + } + + public void setYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) { + setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); + } + + public void setYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime + , int timedInvokeTimeoutMs) { + setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs); + } + + public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback + , Integer yearDayIndex, Integer userIndex) { + getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); + } + + public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback + , Integer yearDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { + getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); + } + + public void clearYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex) { + clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); + } + + public void clearYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { + clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); + } + + public void setHolidaySchedule(DefaultClusterCallback callback + , Integer holidayIndex, Long localStartTime, Long localEndTime, Integer operatingMode) { + setHolidaySchedule(chipClusterPtr, callback, holidayIndex, localStartTime, localEndTime, operatingMode, null); + } + + public void setHolidaySchedule(DefaultClusterCallback callback + , Integer holidayIndex, Long localStartTime, Long localEndTime, Integer operatingMode + , int timedInvokeTimeoutMs) { + setHolidaySchedule(chipClusterPtr, callback, holidayIndex, localStartTime, localEndTime, operatingMode, timedInvokeTimeoutMs); + } + + public void getHolidaySchedule(GetHolidayScheduleResponseCallback callback + , Integer holidayIndex) { + getHolidaySchedule(chipClusterPtr, callback, holidayIndex, null); + } + + public void getHolidaySchedule(GetHolidayScheduleResponseCallback callback + , Integer holidayIndex + , int timedInvokeTimeoutMs) { + getHolidaySchedule(chipClusterPtr, callback, holidayIndex, timedInvokeTimeoutMs); + } + + public void clearHolidaySchedule(DefaultClusterCallback callback + , Integer holidayIndex) { + clearHolidaySchedule(chipClusterPtr, callback, holidayIndex, null); + } + + public void clearHolidaySchedule(DefaultClusterCallback callback + , Integer holidayIndex + , int timedInvokeTimeoutMs) { + clearHolidaySchedule(chipClusterPtr, callback, holidayIndex, timedInvokeTimeoutMs); + } + + + public void setUser(DefaultClusterCallback callback + , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueID, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule + , int timedInvokeTimeoutMs) { + setUser(chipClusterPtr, callback, operationType, userIndex, userName, userUniqueID, userStatus, userType, credentialRule, timedInvokeTimeoutMs); + } + + public void getUser(GetUserResponseCallback callback + , Integer userIndex) { + getUser(chipClusterPtr, callback, userIndex, null); + } + + public void getUser(GetUserResponseCallback callback + , Integer userIndex + , int timedInvokeTimeoutMs) { + getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); + } + + + public void clearUser(DefaultClusterCallback callback + , Integer userIndex + , int timedInvokeTimeoutMs) { + clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); + } + + + public void setCredential(SetCredentialResponseCallback callback + , Integer operationType, ChipStructs.DoorLockClusterCredentialStruct credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType + , int timedInvokeTimeoutMs) { + setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs); + } + + public void getCredentialStatus(GetCredentialStatusResponseCallback callback + , ChipStructs.DoorLockClusterCredentialStruct credential) { + getCredentialStatus(chipClusterPtr, callback, credential, null); + } + + public void getCredentialStatus(GetCredentialStatusResponseCallback callback + , ChipStructs.DoorLockClusterCredentialStruct credential + , int timedInvokeTimeoutMs) { + getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); + } + + + public void clearCredential(DefaultClusterCallback callback + , @Nullable ChipStructs.DoorLockClusterCredentialStruct credential + , int timedInvokeTimeoutMs) { + clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); + } + + + public void unboltDoor(DefaultClusterCallback callback + , Optional PINCode + , int timedInvokeTimeoutMs) { + unboltDoor(chipClusterPtr, callback, PINCode, timedInvokeTimeoutMs); + } + private native void lockDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional PINCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional PINCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback Callback + , Integer timeout, Optional PINCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void setWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute + , @Nullable Integer timedInvokeTimeoutMs); + private native void getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback Callback + , Integer weekDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer weekDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void setYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback Callback + , Integer yearDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer yearDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void setHolidaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer holidayIndex, Long localStartTime, Long localEndTime, Integer operatingMode + , @Nullable Integer timedInvokeTimeoutMs); + private native void getHolidaySchedule(long chipClusterPtr, GetHolidayScheduleResponseCallback Callback + , Integer holidayIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearHolidaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer holidayIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void setUser(long chipClusterPtr, DefaultClusterCallback Callback + , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueID, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule + , @Nullable Integer timedInvokeTimeoutMs); + private native void getUser(long chipClusterPtr, GetUserResponseCallback Callback + , Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearUser(long chipClusterPtr, DefaultClusterCallback Callback + , Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback Callback + , Integer operationType, ChipStructs.DoorLockClusterCredentialStruct credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType + , @Nullable Integer timedInvokeTimeoutMs); + private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback Callback + , ChipStructs.DoorLockClusterCredentialStruct credential + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearCredential(long chipClusterPtr, DefaultClusterCallback Callback + , @Nullable ChipStructs.DoorLockClusterCredentialStruct credential + , @Nullable Integer timedInvokeTimeoutMs); + private native void unboltDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional PINCode + , @Nullable Integer timedInvokeTimeoutMs); + public interface GetWeekDayScheduleResponseCallback { + void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); + + void onError(Exception error); + } + + public interface GetYearDayScheduleResponseCallback { + void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); + + void onError(Exception error); + } + + public interface GetHolidayScheduleResponseCallback { + void onSuccess(Integer holidayIndex, Integer status, Optional localStartTime, Optional localEndTime, Optional operatingMode); + + void onError(Exception error); + } + + public interface GetUserResponseCallback { + void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueID, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); + + void onError(Exception error); + } + + public interface SetCredentialResponseCallback { + void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + + void onError(Exception error); + } + + public interface GetCredentialStatusResponseCallback { + void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextCredentialIndex); + + void onError(Exception error); + } + + + public interface LockStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DoorStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readLockStateAttribute( + LockStateAttributeCallback callback + ) { + readLockStateAttribute(chipClusterPtr, callback); + } + public void subscribeLockStateAttribute( + LockStateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLockTypeAttribute( + IntegerAttributeCallback callback + ) { + readLockTypeAttribute(chipClusterPtr, callback); + } + public void subscribeLockTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActuatorEnabledAttribute( + BooleanAttributeCallback callback + ) { + readActuatorEnabledAttribute(chipClusterPtr, callback); + } + public void subscribeActuatorEnabledAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDoorStateAttribute( + DoorStateAttributeCallback callback + ) { + readDoorStateAttribute(chipClusterPtr, callback); + } + public void subscribeDoorStateAttribute( + DoorStateAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDoorOpenEventsAttribute( + LongAttributeCallback callback + ) { + readDoorOpenEventsAttribute(chipClusterPtr, callback); + } + public void writeDoorOpenEventsAttribute(DefaultClusterCallback callback, Long value) { + writeDoorOpenEventsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeDoorOpenEventsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeDoorOpenEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeDoorOpenEventsAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDoorOpenEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDoorClosedEventsAttribute( + LongAttributeCallback callback + ) { + readDoorClosedEventsAttribute(chipClusterPtr, callback); + } + public void writeDoorClosedEventsAttribute(DefaultClusterCallback callback, Long value) { + writeDoorClosedEventsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeDoorClosedEventsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeDoorClosedEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeDoorClosedEventsAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDoorClosedEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOpenPeriodAttribute( + IntegerAttributeCallback callback + ) { + readOpenPeriodAttribute(chipClusterPtr, callback); + } + public void writeOpenPeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeOpenPeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOpenPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOpenPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOpenPeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOpenPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfTotalUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfTotalUsersSupportedAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfPINUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfPINUsersSupportedAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfRFIDUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfRFIDUsersSupportedAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfYearDaySchedulesSupportedPerUserAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfHolidaySchedulesSupportedAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfHolidaySchedulesSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfHolidaySchedulesSupportedAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfHolidaySchedulesSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxPINCodeLengthAttribute( + IntegerAttributeCallback callback + ) { + readMaxPINCodeLengthAttribute(chipClusterPtr, callback); + } + public void subscribeMaxPINCodeLengthAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinPINCodeLengthAttribute( + IntegerAttributeCallback callback + ) { + readMinPINCodeLengthAttribute(chipClusterPtr, callback); + } + public void subscribeMinPINCodeLengthAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxRFIDCodeLengthAttribute( + IntegerAttributeCallback callback + ) { + readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback); + } + public void subscribeMaxRFIDCodeLengthAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinRFIDCodeLengthAttribute( + IntegerAttributeCallback callback + ) { + readMinRFIDCodeLengthAttribute(chipClusterPtr, callback); + } + public void subscribeMinRFIDCodeLengthAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCredentialRulesSupportAttribute( + IntegerAttributeCallback callback + ) { + readCredentialRulesSupportAttribute(chipClusterPtr, callback); + } + public void subscribeCredentialRulesSupportAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCredentialRulesSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfCredentialsSupportedPerUserAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfCredentialsSupportedPerUserAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfCredentialsSupportedPerUserAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfCredentialsSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLanguageAttribute( + CharStringAttributeCallback callback + ) { + readLanguageAttribute(chipClusterPtr, callback); + } + public void writeLanguageAttribute(DefaultClusterCallback callback, String value) { + writeLanguageAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLanguageAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLEDSettingsAttribute( + IntegerAttributeCallback callback + ) { + readLEDSettingsAttribute(chipClusterPtr, callback); + } + public void writeLEDSettingsAttribute(DefaultClusterCallback callback, Integer value) { + writeLEDSettingsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLEDSettingsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeLEDSettingsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLEDSettingsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLEDSettingsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAutoRelockTimeAttribute( + LongAttributeCallback callback + ) { + readAutoRelockTimeAttribute(chipClusterPtr, callback); + } + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) { + writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAutoRelockTimeAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSoundVolumeAttribute( + IntegerAttributeCallback callback + ) { + readSoundVolumeAttribute(chipClusterPtr, callback); + } + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) { + writeSoundVolumeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSoundVolumeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperatingModeAttribute( + IntegerAttributeCallback callback + ) { + readOperatingModeAttribute(chipClusterPtr, callback); + } + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOperatingModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOperatingModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedOperatingModesAttribute( + IntegerAttributeCallback callback + ) { + readSupportedOperatingModesAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedOperatingModesAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDefaultConfigurationRegisterAttribute( + IntegerAttributeCallback callback + ) { + readDefaultConfigurationRegisterAttribute(chipClusterPtr, callback); + } + public void subscribeDefaultConfigurationRegisterAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDefaultConfigurationRegisterAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnableLocalProgrammingAttribute( + BooleanAttributeCallback callback + ) { + readEnableLocalProgrammingAttribute(chipClusterPtr, callback); + } + public void writeEnableLocalProgrammingAttribute(DefaultClusterCallback callback, Boolean value) { + writeEnableLocalProgrammingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEnableLocalProgrammingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeEnableLocalProgrammingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnableLocalProgrammingAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnableLocalProgrammingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnableOneTouchLockingAttribute( + BooleanAttributeCallback callback + ) { + readEnableOneTouchLockingAttribute(chipClusterPtr, callback); + } + public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) { + writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnableOneTouchLockingAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnableInsideStatusLEDAttribute( + BooleanAttributeCallback callback + ) { + readEnableInsideStatusLEDAttribute(chipClusterPtr, callback); + } + public void writeEnableInsideStatusLEDAttribute(DefaultClusterCallback callback, Boolean value) { + writeEnableInsideStatusLEDAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEnableInsideStatusLEDAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeEnableInsideStatusLEDAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnableInsideStatusLEDAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnableInsideStatusLEDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnablePrivacyModeButtonAttribute( + BooleanAttributeCallback callback + ) { + readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback); + } + public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) { + writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnablePrivacyModeButtonAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLocalProgrammingFeaturesAttribute( + IntegerAttributeCallback callback + ) { + readLocalProgrammingFeaturesAttribute(chipClusterPtr, callback); + } + public void writeLocalProgrammingFeaturesAttribute(DefaultClusterCallback callback, Integer value) { + writeLocalProgrammingFeaturesAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLocalProgrammingFeaturesAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeLocalProgrammingFeaturesAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLocalProgrammingFeaturesAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLocalProgrammingFeaturesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWrongCodeEntryLimitAttribute( + IntegerAttributeCallback callback + ) { + readWrongCodeEntryLimitAttribute(chipClusterPtr, callback); + } + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) { + writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null); + } + + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeWrongCodeEntryLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUserCodeTemporaryDisableTimeAttribute( + IntegerAttributeCallback callback + ) { + readUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback); + } + public void writeUserCodeTemporaryDisableTimeAttribute(DefaultClusterCallback callback, Integer value) { + writeUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUserCodeTemporaryDisableTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUserCodeTemporaryDisableTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSendPINOverTheAirAttribute( + BooleanAttributeCallback callback + ) { + readSendPINOverTheAirAttribute(chipClusterPtr, callback); + } + public void writeSendPINOverTheAirAttribute(DefaultClusterCallback callback, Boolean value) { + writeSendPINOverTheAirAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSendPINOverTheAirAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeSendPINOverTheAirAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSendPINOverTheAirAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSendPINOverTheAirAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRequirePINforRemoteOperationAttribute( + BooleanAttributeCallback callback + ) { + readRequirePINforRemoteOperationAttribute(chipClusterPtr, callback); + } + public void writeRequirePINforRemoteOperationAttribute(DefaultClusterCallback callback, Boolean value) { + writeRequirePINforRemoteOperationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRequirePINforRemoteOperationAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeRequirePINforRemoteOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRequirePINforRemoteOperationAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRequirePINforRemoteOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readExpiringUserTimeoutAttribute( + IntegerAttributeCallback callback + ) { + readExpiringUserTimeoutAttribute(chipClusterPtr, callback); + } + public void writeExpiringUserTimeoutAttribute(DefaultClusterCallback callback, Integer value) { + writeExpiringUserTimeoutAttribute(chipClusterPtr, callback, value, null); + } + + public void writeExpiringUserTimeoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeExpiringUserTimeoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeExpiringUserTimeoutAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeExpiringUserTimeoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readLockStateAttribute(long chipClusterPtr, + LockStateAttributeCallback callback + ); + private native void subscribeLockStateAttribute(long chipClusterPtr, + LockStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLockTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLockTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActuatorEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDoorStateAttribute(long chipClusterPtr, + DoorStateAttributeCallback callback + ); + private native void subscribeDoorStateAttribute(long chipClusterPtr, + DoorStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDoorOpenEventsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeDoorOpenEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDoorOpenEventsAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDoorClosedEventsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeDoorClosedEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDoorClosedEventsAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOpenPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOpenPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOpenPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfHolidaySchedulesSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfHolidaySchedulesSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCredentialRulesSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCredentialRulesSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfCredentialsSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfCredentialsSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLanguageAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLanguageAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLanguageAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLEDSettingsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeLEDSettingsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLEDSettingsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAutoRelockTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeAutoRelockTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAutoRelockTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoundVolumeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSoundVolumeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSoundVolumeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOperatingModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOperatingModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOperatingModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedOperatingModesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSupportedOperatingModesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDefaultConfigurationRegisterAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDefaultConfigurationRegisterAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnableLocalProgrammingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnableLocalProgrammingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnableLocalProgrammingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnableOneTouchLockingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnableOneTouchLockingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnableOneTouchLockingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnableInsideStatusLEDAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnableInsideStatusLEDAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnableInsideStatusLEDAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnablePrivacyModeButtonAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnablePrivacyModeButtonAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnablePrivacyModeButtonAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocalProgrammingFeaturesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeLocalProgrammingFeaturesAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocalProgrammingFeaturesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWrongCodeEntryLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWrongCodeEntryLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWrongCodeEntryLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUserCodeTemporaryDisableTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeUserCodeTemporaryDisableTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUserCodeTemporaryDisableTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSendPINOverTheAirAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeSendPINOverTheAirAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSendPINOverTheAirAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRequirePINforRemoteOperationAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeRequirePINforRemoteOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRequirePINforRemoteOperationAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readExpiringUserTimeoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeExpiringUserTimeoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeExpiringUserTimeoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class WindowCoveringCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000102L; + + public WindowCoveringCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void upOrOpen(DefaultClusterCallback callback + ) { + upOrOpen(chipClusterPtr, callback, null); + } + + public void upOrOpen(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void downOrClose(DefaultClusterCallback callback + ) { + downOrClose(chipClusterPtr, callback, null); + } + + public void downOrClose(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void stopMotion(DefaultClusterCallback callback + ) { + stopMotion(chipClusterPtr, callback, null); + } + + public void stopMotion(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void goToLiftValue(DefaultClusterCallback callback + , Integer liftValue) { + goToLiftValue(chipClusterPtr, callback, liftValue, null); + } + + public void goToLiftValue(DefaultClusterCallback callback + , Integer liftValue + , int timedInvokeTimeoutMs) { + goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs); + } + + public void goToLiftPercentage(DefaultClusterCallback callback + , Integer liftPercent100thsValue) { + goToLiftPercentage(chipClusterPtr, callback, liftPercent100thsValue, null); + } + + public void goToLiftPercentage(DefaultClusterCallback callback + , Integer liftPercent100thsValue + , int timedInvokeTimeoutMs) { + goToLiftPercentage(chipClusterPtr, callback, liftPercent100thsValue, timedInvokeTimeoutMs); + } + + public void goToTiltValue(DefaultClusterCallback callback + , Integer tiltValue) { + goToTiltValue(chipClusterPtr, callback, tiltValue, null); + } + + public void goToTiltValue(DefaultClusterCallback callback + , Integer tiltValue + , int timedInvokeTimeoutMs) { + goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs); + } + + public void goToTiltPercentage(DefaultClusterCallback callback + , Integer tiltPercent100thsValue) { + goToTiltPercentage(chipClusterPtr, callback, tiltPercent100thsValue, null); + } + + public void goToTiltPercentage(DefaultClusterCallback callback + , Integer tiltPercent100thsValue + , int timedInvokeTimeoutMs) { + goToTiltPercentage(chipClusterPtr, callback, tiltPercent100thsValue, timedInvokeTimeoutMs); + } + private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer liftValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback + , Integer liftPercent100thsValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer tiltValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback Callback + , Integer tiltPercent100thsValue + , @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentPositionLiftAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPositionTiltAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPositionLiftPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPositionTiltPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TargetPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TargetPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CurrentPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readTypeAttribute( + IntegerAttributeCallback callback + ) { + readTypeAttribute(chipClusterPtr, callback); + } + public void subscribeTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhysicalClosedLimitLiftAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalClosedLimitLiftAttribute(chipClusterPtr, callback); + } + public void subscribePhysicalClosedLimitLiftAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhysicalClosedLimitTiltAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalClosedLimitTiltAttribute(chipClusterPtr, callback); + } + public void subscribePhysicalClosedLimitTiltAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionLiftAttribute( + CurrentPositionLiftAttributeCallback callback + ) { + readCurrentPositionLiftAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionLiftAttribute( + CurrentPositionLiftAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionTiltAttribute( + CurrentPositionTiltAttributeCallback callback + ) { + readCurrentPositionTiltAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionTiltAttribute( + CurrentPositionTiltAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfActuationsLiftAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfActuationsLiftAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfActuationsLiftAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfActuationsLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfActuationsTiltAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfActuationsTiltAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfActuationsTiltAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfActuationsTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readConfigStatusAttribute( + IntegerAttributeCallback callback + ) { + readConfigStatusAttribute(chipClusterPtr, callback); + } + public void subscribeConfigStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionLiftPercentageAttribute( + CurrentPositionLiftPercentageAttributeCallback callback + ) { + readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionLiftPercentageAttribute( + CurrentPositionLiftPercentageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionTiltPercentageAttribute( + CurrentPositionTiltPercentageAttributeCallback callback + ) { + readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionTiltPercentageAttribute( + CurrentPositionTiltPercentageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalStatusAttribute( + IntegerAttributeCallback callback + ) { + readOperationalStatusAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTargetPositionLiftPercent100thsAttribute( + TargetPositionLiftPercent100thsAttributeCallback callback + ) { + readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback); + } + public void subscribeTargetPositionLiftPercent100thsAttribute( + TargetPositionLiftPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTargetPositionTiltPercent100thsAttribute( + TargetPositionTiltPercent100thsAttributeCallback callback + ) { + readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback); + } + public void subscribeTargetPositionTiltPercent100thsAttribute( + TargetPositionTiltPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEndProductTypeAttribute( + IntegerAttributeCallback callback + ) { + readEndProductTypeAttribute(chipClusterPtr, callback); + } + public void subscribeEndProductTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionLiftPercent100thsAttribute( + CurrentPositionLiftPercent100thsAttributeCallback callback + ) { + readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionLiftPercent100thsAttribute( + CurrentPositionLiftPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentPositionTiltPercent100thsAttribute( + CurrentPositionTiltPercent100thsAttributeCallback callback + ) { + readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentPositionTiltPercent100thsAttribute( + CurrentPositionTiltPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstalledOpenLimitLiftAttribute( + IntegerAttributeCallback callback + ) { + readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback); + } + public void subscribeInstalledOpenLimitLiftAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstalledClosedLimitLiftAttribute( + IntegerAttributeCallback callback + ) { + readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback); + } + public void subscribeInstalledClosedLimitLiftAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstalledOpenLimitTiltAttribute( + IntegerAttributeCallback callback + ) { + readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback); + } + public void subscribeInstalledOpenLimitTiltAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstalledClosedLimitTiltAttribute( + IntegerAttributeCallback callback + ) { + readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback); + } + public void subscribeInstalledClosedLimitTiltAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readModeAttribute( + IntegerAttributeCallback callback + ) { + readModeAttribute(chipClusterPtr, callback); + } + public void writeModeAttribute(DefaultClusterCallback callback, Integer value) { + writeModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSafetyStatusAttribute( + IntegerAttributeCallback callback + ) { + readSafetyStatusAttribute(chipClusterPtr, callback); + } + public void subscribeSafetyStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhysicalClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePhysicalClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhysicalClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePhysicalClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftAttribute(long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftAttribute(long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltAttribute(long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltAttribute(long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNumberOfActuationsLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfActuationsLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfActuationsTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfActuationsTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readConfigStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConfigStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercentageAttribute(long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftPercentageAttribute(long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltPercentageAttribute(long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltPercentageAttribute(long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOperationalStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback + ); + private native void subscribeTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback + ); + private native void subscribeTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndProductTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEndProductTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readInstalledOpenLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledOpenLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledOpenLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledOpenLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BarrierControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000103L; + + public BarrierControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void barrierControlGoToPercent(DefaultClusterCallback callback + , Integer percentOpen) { + barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null); + } + + public void barrierControlGoToPercent(DefaultClusterCallback callback + , Integer percentOpen + , int timedInvokeTimeoutMs) { + barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs); + } + + public void barrierControlStop(DefaultClusterCallback callback + ) { + barrierControlStop(chipClusterPtr, callback, null); + } + + public void barrierControlStop(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback Callback + , Integer percentOpen + , @Nullable Integer timedInvokeTimeoutMs); + private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readBarrierMovingStateAttribute( + IntegerAttributeCallback callback + ) { + readBarrierMovingStateAttribute(chipClusterPtr, callback); + } + public void subscribeBarrierMovingStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierSafetyStatusAttribute( + IntegerAttributeCallback callback + ) { + readBarrierSafetyStatusAttribute(chipClusterPtr, callback); + } + public void subscribeBarrierSafetyStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierCapabilitiesAttribute( + IntegerAttributeCallback callback + ) { + readBarrierCapabilitiesAttribute(chipClusterPtr, callback); + } + public void subscribeBarrierCapabilitiesAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierOpenEventsAttribute( + IntegerAttributeCallback callback + ) { + readBarrierOpenEventsAttribute(chipClusterPtr, callback); + } + public void writeBarrierOpenEventsAttribute(DefaultClusterCallback callback, Integer value) { + writeBarrierOpenEventsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBarrierOpenEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBarrierOpenEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBarrierOpenEventsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierOpenEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierCloseEventsAttribute( + IntegerAttributeCallback callback + ) { + readBarrierCloseEventsAttribute(chipClusterPtr, callback); + } + public void writeBarrierCloseEventsAttribute(DefaultClusterCallback callback, Integer value) { + writeBarrierCloseEventsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBarrierCloseEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBarrierCloseEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBarrierCloseEventsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierCloseEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierCommandOpenEventsAttribute( + IntegerAttributeCallback callback + ) { + readBarrierCommandOpenEventsAttribute(chipClusterPtr, callback); + } + public void writeBarrierCommandOpenEventsAttribute(DefaultClusterCallback callback, Integer value) { + writeBarrierCommandOpenEventsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBarrierCommandOpenEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBarrierCommandOpenEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBarrierCommandOpenEventsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierCommandOpenEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierCommandCloseEventsAttribute( + IntegerAttributeCallback callback + ) { + readBarrierCommandCloseEventsAttribute(chipClusterPtr, callback); + } + public void writeBarrierCommandCloseEventsAttribute(DefaultClusterCallback callback, Integer value) { + writeBarrierCommandCloseEventsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBarrierCommandCloseEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBarrierCommandCloseEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBarrierCommandCloseEventsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierCommandCloseEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierOpenPeriodAttribute( + IntegerAttributeCallback callback + ) { + readBarrierOpenPeriodAttribute(chipClusterPtr, callback); + } + public void writeBarrierOpenPeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeBarrierOpenPeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBarrierOpenPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBarrierOpenPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBarrierOpenPeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierOpenPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierClosePeriodAttribute( + IntegerAttributeCallback callback + ) { + readBarrierClosePeriodAttribute(chipClusterPtr, callback); + } + public void writeBarrierClosePeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeBarrierClosePeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBarrierClosePeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBarrierClosePeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBarrierClosePeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierClosePeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBarrierPositionAttribute( + IntegerAttributeCallback callback + ) { + readBarrierPositionAttribute(chipClusterPtr, callback); + } + public void subscribeBarrierPositionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readBarrierMovingStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierMovingStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierOpenEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBarrierOpenEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBarrierOpenEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierCloseEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBarrierCloseEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBarrierCloseEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierCommandOpenEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBarrierCommandOpenEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBarrierCommandOpenEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierCommandCloseEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBarrierCommandCloseEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBarrierCommandCloseEventsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierOpenPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBarrierOpenPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBarrierOpenPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierClosePeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBarrierClosePeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBarrierClosePeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class PumpConfigurationAndControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000200L; + + public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MaxPressureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxSpeedAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxFlowAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinConstPressureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxConstPressureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinCompPressureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxCompPressureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinConstSpeedAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxConstSpeedAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinConstFlowAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxConstFlowAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinConstTempAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxConstTempAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface CapacityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SpeedAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LifetimeRunningHoursAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PowerAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LifetimeEnergyConsumedAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMaxPressureAttribute( + MaxPressureAttributeCallback callback + ) { + readMaxPressureAttribute(chipClusterPtr, callback); + } + public void subscribeMaxPressureAttribute( + MaxPressureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxSpeedAttribute( + MaxSpeedAttributeCallback callback + ) { + readMaxSpeedAttribute(chipClusterPtr, callback); + } + public void subscribeMaxSpeedAttribute( + MaxSpeedAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxFlowAttribute( + MaxFlowAttributeCallback callback + ) { + readMaxFlowAttribute(chipClusterPtr, callback); + } + public void subscribeMaxFlowAttribute( + MaxFlowAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinConstPressureAttribute( + MinConstPressureAttributeCallback callback + ) { + readMinConstPressureAttribute(chipClusterPtr, callback); + } + public void subscribeMinConstPressureAttribute( + MinConstPressureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxConstPressureAttribute( + MaxConstPressureAttributeCallback callback + ) { + readMaxConstPressureAttribute(chipClusterPtr, callback); + } + public void subscribeMaxConstPressureAttribute( + MaxConstPressureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinCompPressureAttribute( + MinCompPressureAttributeCallback callback + ) { + readMinCompPressureAttribute(chipClusterPtr, callback); + } + public void subscribeMinCompPressureAttribute( + MinCompPressureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxCompPressureAttribute( + MaxCompPressureAttributeCallback callback + ) { + readMaxCompPressureAttribute(chipClusterPtr, callback); + } + public void subscribeMaxCompPressureAttribute( + MaxCompPressureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinConstSpeedAttribute( + MinConstSpeedAttributeCallback callback + ) { + readMinConstSpeedAttribute(chipClusterPtr, callback); + } + public void subscribeMinConstSpeedAttribute( + MinConstSpeedAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxConstSpeedAttribute( + MaxConstSpeedAttributeCallback callback + ) { + readMaxConstSpeedAttribute(chipClusterPtr, callback); + } + public void subscribeMaxConstSpeedAttribute( + MaxConstSpeedAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinConstFlowAttribute( + MinConstFlowAttributeCallback callback + ) { + readMinConstFlowAttribute(chipClusterPtr, callback); + } + public void subscribeMinConstFlowAttribute( + MinConstFlowAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxConstFlowAttribute( + MaxConstFlowAttributeCallback callback + ) { + readMaxConstFlowAttribute(chipClusterPtr, callback); + } + public void subscribeMaxConstFlowAttribute( + MaxConstFlowAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinConstTempAttribute( + MinConstTempAttributeCallback callback + ) { + readMinConstTempAttribute(chipClusterPtr, callback); + } + public void subscribeMinConstTempAttribute( + MinConstTempAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxConstTempAttribute( + MaxConstTempAttributeCallback callback + ) { + readMaxConstTempAttribute(chipClusterPtr, callback); + } + public void subscribeMaxConstTempAttribute( + MaxConstTempAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPumpStatusAttribute( + IntegerAttributeCallback callback + ) { + readPumpStatusAttribute(chipClusterPtr, callback); + } + public void subscribePumpStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEffectiveOperationModeAttribute( + IntegerAttributeCallback callback + ) { + readEffectiveOperationModeAttribute(chipClusterPtr, callback); + } + public void subscribeEffectiveOperationModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEffectiveControlModeAttribute( + IntegerAttributeCallback callback + ) { + readEffectiveControlModeAttribute(chipClusterPtr, callback); + } + public void subscribeEffectiveControlModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCapacityAttribute( + CapacityAttributeCallback callback + ) { + readCapacityAttribute(chipClusterPtr, callback); + } + public void subscribeCapacityAttribute( + CapacityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSpeedAttribute( + SpeedAttributeCallback callback + ) { + readSpeedAttribute(chipClusterPtr, callback); + } + public void subscribeSpeedAttribute( + SpeedAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLifetimeRunningHoursAttribute( + LifetimeRunningHoursAttributeCallback callback + ) { + readLifetimeRunningHoursAttribute(chipClusterPtr, callback); + } + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) { + writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLifetimeRunningHoursAttribute( + LifetimeRunningHoursAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPowerAttribute( + PowerAttributeCallback callback + ) { + readPowerAttribute(chipClusterPtr, callback); + } + public void subscribePowerAttribute( + PowerAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLifetimeEnergyConsumedAttribute( + LifetimeEnergyConsumedAttributeCallback callback + ) { + readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback); + } + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) { + writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLifetimeEnergyConsumedAttribute( + LifetimeEnergyConsumedAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationModeAttribute( + IntegerAttributeCallback callback + ) { + readOperationModeAttribute(chipClusterPtr, callback); + } + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) { + writeOperationModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOperationModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readControlModeAttribute( + IntegerAttributeCallback callback + ) { + readControlModeAttribute(chipClusterPtr, callback); + } + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) { + writeControlModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeControlModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMaxPressureAttribute(long chipClusterPtr, + MaxPressureAttributeCallback callback + ); + private native void subscribeMaxPressureAttribute(long chipClusterPtr, + MaxPressureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxSpeedAttribute(long chipClusterPtr, + MaxSpeedAttributeCallback callback + ); + private native void subscribeMaxSpeedAttribute(long chipClusterPtr, + MaxSpeedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxFlowAttribute(long chipClusterPtr, + MaxFlowAttributeCallback callback + ); + private native void subscribeMaxFlowAttribute(long chipClusterPtr, + MaxFlowAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinConstPressureAttribute(long chipClusterPtr, + MinConstPressureAttributeCallback callback + ); + private native void subscribeMinConstPressureAttribute(long chipClusterPtr, + MinConstPressureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxConstPressureAttribute(long chipClusterPtr, + MaxConstPressureAttributeCallback callback + ); + private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, + MaxConstPressureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinCompPressureAttribute(long chipClusterPtr, + MinCompPressureAttributeCallback callback + ); + private native void subscribeMinCompPressureAttribute(long chipClusterPtr, + MinCompPressureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxCompPressureAttribute(long chipClusterPtr, + MaxCompPressureAttributeCallback callback + ); + private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, + MaxCompPressureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinConstSpeedAttribute(long chipClusterPtr, + MinConstSpeedAttributeCallback callback + ); + private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, + MinConstSpeedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxConstSpeedAttribute(long chipClusterPtr, + MaxConstSpeedAttributeCallback callback + ); + private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, + MaxConstSpeedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinConstFlowAttribute(long chipClusterPtr, + MinConstFlowAttributeCallback callback + ); + private native void subscribeMinConstFlowAttribute(long chipClusterPtr, + MinConstFlowAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxConstFlowAttribute(long chipClusterPtr, + MaxConstFlowAttributeCallback callback + ); + private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, + MaxConstFlowAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinConstTempAttribute(long chipClusterPtr, + MinConstTempAttributeCallback callback + ); + private native void subscribeMinConstTempAttribute(long chipClusterPtr, + MinConstTempAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxConstTempAttribute(long chipClusterPtr, + MaxConstTempAttributeCallback callback + ); + private native void subscribeMaxConstTempAttribute(long chipClusterPtr, + MaxConstTempAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPumpStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePumpStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEffectiveOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEffectiveOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEffectiveControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEffectiveControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCapacityAttribute(long chipClusterPtr, + CapacityAttributeCallback callback + ); + private native void subscribeCapacityAttribute(long chipClusterPtr, + CapacityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSpeedAttribute(long chipClusterPtr, + SpeedAttributeCallback callback + ); + private native void subscribeSpeedAttribute(long chipClusterPtr, + SpeedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLifetimeRunningHoursAttribute(long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback + ); + + private native void writeLifetimeRunningHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLifetimeRunningHoursAttribute(long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPowerAttribute(long chipClusterPtr, + PowerAttributeCallback callback + ); + private native void subscribePowerAttribute(long chipClusterPtr, + PowerAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLifetimeEnergyConsumedAttribute(long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback + ); + + private native void writeLifetimeEnergyConsumedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLifetimeEnergyConsumedAttribute(long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeControlModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ThermostatCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000201L; + + public ThermostatCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void setpointRaiseLower(DefaultClusterCallback callback + , Integer mode, Integer amount) { + setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); + } + + public void setpointRaiseLower(DefaultClusterCallback callback + , Integer mode, Integer amount + , int timedInvokeTimeoutMs) { + setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); + } + + public void setWeeklySchedule(DefaultClusterCallback callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList transitions) { + setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, transitions, null); + } + + public void setWeeklySchedule(DefaultClusterCallback callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList transitions + , int timedInvokeTimeoutMs) { + setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, transitions, timedInvokeTimeoutMs); + } + + public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback + , Integer daysToReturn, Integer modeToReturn) { + getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null); + } + + public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback + , Integer daysToReturn, Integer modeToReturn + , int timedInvokeTimeoutMs) { + getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs); + } + + public void clearWeeklySchedule(DefaultClusterCallback callback + ) { + clearWeeklySchedule(chipClusterPtr, callback, null); + } + + public void clearWeeklySchedule(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback Callback + , Integer mode, Integer amount + , @Nullable Integer timedInvokeTimeoutMs); + private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList transitions + , @Nullable Integer timedInvokeTimeoutMs); + private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback + , Integer daysToReturn, Integer modeToReturn + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface GetWeeklyScheduleResponseCallback { + void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList transitions); + + void onError(Exception error); + } + + + public interface LocalTemperatureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OutdoorTemperatureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface TemperatureSetpointHoldDurationAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SetpointChangeAmountAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OccupiedSetbackAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OccupiedSetbackMinAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface OccupiedSetbackMaxAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface UnoccupiedSetbackAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface UnoccupiedSetbackMinAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface UnoccupiedSetbackMaxAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ACCoilTemperatureAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readLocalTemperatureAttribute( + LocalTemperatureAttributeCallback callback + ) { + readLocalTemperatureAttribute(chipClusterPtr, callback); + } + public void subscribeLocalTemperatureAttribute( + LocalTemperatureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOutdoorTemperatureAttribute( + OutdoorTemperatureAttributeCallback callback + ) { + readOutdoorTemperatureAttribute(chipClusterPtr, callback); + } + public void subscribeOutdoorTemperatureAttribute( + OutdoorTemperatureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOutdoorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupancyAttribute( + IntegerAttributeCallback callback + ) { + readOccupancyAttribute(chipClusterPtr, callback); + } + public void subscribeOccupancyAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAbsMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback); + } + public void subscribeAbsMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAbsMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); + } + public void subscribeAbsMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAbsMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback); + } + public void subscribeAbsMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAbsMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); + } + public void subscribeAbsMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPICoolingDemandAttribute( + IntegerAttributeCallback callback + ) { + readPICoolingDemandAttribute(chipClusterPtr, callback); + } + public void subscribePICoolingDemandAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePICoolingDemandAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPIHeatingDemandAttribute( + IntegerAttributeCallback callback + ) { + readPIHeatingDemandAttribute(chipClusterPtr, callback); + } + public void subscribePIHeatingDemandAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePIHeatingDemandAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHVACSystemTypeConfigurationAttribute( + IntegerAttributeCallback callback + ) { + readHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback); + } + public void writeHVACSystemTypeConfigurationAttribute(DefaultClusterCallback callback, Integer value) { + writeHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeHVACSystemTypeConfigurationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeHVACSystemTypeConfigurationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLocalTemperatureCalibrationAttribute( + IntegerAttributeCallback callback + ) { + readLocalTemperatureCalibrationAttribute(chipClusterPtr, callback); + } + public void writeLocalTemperatureCalibrationAttribute(DefaultClusterCallback callback, Integer value) { + writeLocalTemperatureCalibrationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLocalTemperatureCalibrationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeLocalTemperatureCalibrationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLocalTemperatureCalibrationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLocalTemperatureCalibrationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupiedCoolingSetpointAttribute( + IntegerAttributeCallback callback + ) { + readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback); + } + public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOccupiedCoolingSetpointAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupiedHeatingSetpointAttribute( + IntegerAttributeCallback callback + ) { + readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback); + } + public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOccupiedHeatingSetpointAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUnoccupiedCoolingSetpointAttribute( + IntegerAttributeCallback callback + ) { + readUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback); + } + public void writeUnoccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + writeUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUnoccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUnoccupiedCoolingSetpointAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUnoccupiedHeatingSetpointAttribute( + IntegerAttributeCallback callback + ) { + readUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback); + } + public void writeUnoccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + writeUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUnoccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUnoccupiedHeatingSetpointAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readMinHeatSetpointLimitAttribute(chipClusterPtr, callback); + } + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { + writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); + } + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { + writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readMinCoolSetpointLimitAttribute(chipClusterPtr, callback); + } + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { + writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { + readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); + } + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { + writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinSetpointDeadBandAttribute( + IntegerAttributeCallback callback + ) { + readMinSetpointDeadBandAttribute(chipClusterPtr, callback); + } + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) { + writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMinSetpointDeadBandAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRemoteSensingAttribute( + IntegerAttributeCallback callback + ) { + readRemoteSensingAttribute(chipClusterPtr, callback); + } + public void writeRemoteSensingAttribute(DefaultClusterCallback callback, Integer value) { + writeRemoteSensingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRemoteSensingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRemoteSensingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRemoteSensingAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRemoteSensingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readControlSequenceOfOperationAttribute( + IntegerAttributeCallback callback + ) { + readControlSequenceOfOperationAttribute(chipClusterPtr, callback); + } + public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) { + writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeControlSequenceOfOperationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSystemModeAttribute( + IntegerAttributeCallback callback + ) { + readSystemModeAttribute(chipClusterPtr, callback); + } + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) { + writeSystemModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSystemModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readThermostatRunningModeAttribute( + IntegerAttributeCallback callback + ) { + readThermostatRunningModeAttribute(chipClusterPtr, callback); + } + public void subscribeThermostatRunningModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeThermostatRunningModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartOfWeekAttribute( + IntegerAttributeCallback callback + ) { + readStartOfWeekAttribute(chipClusterPtr, callback); + } + public void subscribeStartOfWeekAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfWeeklyTransitionsAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfWeeklyTransitionsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfDailyTransitionsAttribute( + IntegerAttributeCallback callback + ) { + readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfDailyTransitionsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTemperatureSetpointHoldAttribute( + IntegerAttributeCallback callback + ) { + readTemperatureSetpointHoldAttribute(chipClusterPtr, callback); + } + public void writeTemperatureSetpointHoldAttribute(DefaultClusterCallback callback, Integer value) { + writeTemperatureSetpointHoldAttribute(chipClusterPtr, callback, value, null); + } + + public void writeTemperatureSetpointHoldAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeTemperatureSetpointHoldAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeTemperatureSetpointHoldAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTemperatureSetpointHoldAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTemperatureSetpointHoldDurationAttribute( + TemperatureSetpointHoldDurationAttributeCallback callback + ) { + readTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback); + } + public void writeTemperatureSetpointHoldDurationAttribute(DefaultClusterCallback callback, Integer value) { + writeTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback, value, null); + } + + public void writeTemperatureSetpointHoldDurationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeTemperatureSetpointHoldDurationAttribute( + TemperatureSetpointHoldDurationAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readThermostatProgrammingOperationModeAttribute( + IntegerAttributeCallback callback + ) { + readThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback); + } + public void writeThermostatProgrammingOperationModeAttribute(DefaultClusterCallback callback, Integer value) { + writeThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeThermostatProgrammingOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeThermostatProgrammingOperationModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readThermostatRunningStateAttribute( + IntegerAttributeCallback callback + ) { + readThermostatRunningStateAttribute(chipClusterPtr, callback); + } + public void subscribeThermostatRunningStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeThermostatRunningStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSetpointChangeSourceAttribute( + IntegerAttributeCallback callback + ) { + readSetpointChangeSourceAttribute(chipClusterPtr, callback); + } + public void subscribeSetpointChangeSourceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSetpointChangeSourceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSetpointChangeAmountAttribute( + SetpointChangeAmountAttributeCallback callback + ) { + readSetpointChangeAmountAttribute(chipClusterPtr, callback); + } + public void subscribeSetpointChangeAmountAttribute( + SetpointChangeAmountAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSetpointChangeAmountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSetpointChangeSourceTimestampAttribute( + LongAttributeCallback callback + ) { + readSetpointChangeSourceTimestampAttribute(chipClusterPtr, callback); + } + public void subscribeSetpointChangeSourceTimestampAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSetpointChangeSourceTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupiedSetbackAttribute( + OccupiedSetbackAttributeCallback callback + ) { + readOccupiedSetbackAttribute(chipClusterPtr, callback); + } + public void writeOccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value) { + writeOccupiedSetbackAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOccupiedSetbackAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOccupiedSetbackAttribute( + OccupiedSetbackAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOccupiedSetbackAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupiedSetbackMinAttribute( + OccupiedSetbackMinAttributeCallback callback + ) { + readOccupiedSetbackMinAttribute(chipClusterPtr, callback); + } + public void subscribeOccupiedSetbackMinAttribute( + OccupiedSetbackMinAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOccupiedSetbackMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupiedSetbackMaxAttribute( + OccupiedSetbackMaxAttributeCallback callback + ) { + readOccupiedSetbackMaxAttribute(chipClusterPtr, callback); + } + public void subscribeOccupiedSetbackMaxAttribute( + OccupiedSetbackMaxAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOccupiedSetbackMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUnoccupiedSetbackAttribute( + UnoccupiedSetbackAttributeCallback callback + ) { + readUnoccupiedSetbackAttribute(chipClusterPtr, callback); + } + public void writeUnoccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value) { + writeUnoccupiedSetbackAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUnoccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUnoccupiedSetbackAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUnoccupiedSetbackAttribute( + UnoccupiedSetbackAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeUnoccupiedSetbackAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUnoccupiedSetbackMinAttribute( + UnoccupiedSetbackMinAttributeCallback callback + ) { + readUnoccupiedSetbackMinAttribute(chipClusterPtr, callback); + } + public void subscribeUnoccupiedSetbackMinAttribute( + UnoccupiedSetbackMinAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeUnoccupiedSetbackMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUnoccupiedSetbackMaxAttribute( + UnoccupiedSetbackMaxAttributeCallback callback + ) { + readUnoccupiedSetbackMaxAttribute(chipClusterPtr, callback); + } + public void subscribeUnoccupiedSetbackMaxAttribute( + UnoccupiedSetbackMaxAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeUnoccupiedSetbackMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEmergencyHeatDeltaAttribute( + IntegerAttributeCallback callback + ) { + readEmergencyHeatDeltaAttribute(chipClusterPtr, callback); + } + public void writeEmergencyHeatDeltaAttribute(DefaultClusterCallback callback, Integer value) { + writeEmergencyHeatDeltaAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEmergencyHeatDeltaAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeEmergencyHeatDeltaAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEmergencyHeatDeltaAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEmergencyHeatDeltaAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACTypeAttribute( + IntegerAttributeCallback callback + ) { + readACTypeAttribute(chipClusterPtr, callback); + } + public void writeACTypeAttribute(DefaultClusterCallback callback, Integer value) { + writeACTypeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeACTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACCapacityAttribute( + IntegerAttributeCallback callback + ) { + readACCapacityAttribute(chipClusterPtr, callback); + } + public void writeACCapacityAttribute(DefaultClusterCallback callback, Integer value) { + writeACCapacityAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACCapacityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeACCapacityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACCapacityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACRefrigerantTypeAttribute( + IntegerAttributeCallback callback + ) { + readACRefrigerantTypeAttribute(chipClusterPtr, callback); + } + public void writeACRefrigerantTypeAttribute(DefaultClusterCallback callback, Integer value) { + writeACRefrigerantTypeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACRefrigerantTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeACRefrigerantTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACRefrigerantTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACRefrigerantTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACCompressorTypeAttribute( + IntegerAttributeCallback callback + ) { + readACCompressorTypeAttribute(chipClusterPtr, callback); + } + public void writeACCompressorTypeAttribute(DefaultClusterCallback callback, Integer value) { + writeACCompressorTypeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACCompressorTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeACCompressorTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACCompressorTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACCompressorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACErrorCodeAttribute( + LongAttributeCallback callback + ) { + readACErrorCodeAttribute(chipClusterPtr, callback); + } + public void writeACErrorCodeAttribute(DefaultClusterCallback callback, Long value) { + writeACErrorCodeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACErrorCodeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeACErrorCodeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACErrorCodeAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACErrorCodeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACLouverPositionAttribute( + IntegerAttributeCallback callback + ) { + readACLouverPositionAttribute(chipClusterPtr, callback); + } + public void writeACLouverPositionAttribute(DefaultClusterCallback callback, Integer value) { + writeACLouverPositionAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACLouverPositionAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeACLouverPositionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACLouverPositionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACLouverPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACCoilTemperatureAttribute( + ACCoilTemperatureAttributeCallback callback + ) { + readACCoilTemperatureAttribute(chipClusterPtr, callback); + } + public void subscribeACCoilTemperatureAttribute( + ACCoilTemperatureAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeACCoilTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readACCapacityformatAttribute( + IntegerAttributeCallback callback + ) { + readACCapacityformatAttribute(chipClusterPtr, callback); + } + public void writeACCapacityformatAttribute(DefaultClusterCallback callback, Integer value) { + writeACCapacityformatAttribute(chipClusterPtr, callback, value, null); + } + + public void writeACCapacityformatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeACCapacityformatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeACCapacityformatAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeACCapacityformatAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readLocalTemperatureAttribute(long chipClusterPtr, + LocalTemperatureAttributeCallback callback + ); + private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, + LocalTemperatureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOutdoorTemperatureAttribute(long chipClusterPtr, + OutdoorTemperatureAttributeCallback callback + ); + private native void subscribeOutdoorTemperatureAttribute(long chipClusterPtr, + OutdoorTemperatureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPICoolingDemandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePICoolingDemandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPIHeatingDemandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePIHeatingDemandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHVACSystemTypeConfigurationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeHVACSystemTypeConfigurationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeHVACSystemTypeConfigurationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocalTemperatureCalibrationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeLocalTemperatureCalibrationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocalTemperatureCalibrationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUnoccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeUnoccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUnoccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUnoccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeUnoccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUnoccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinSetpointDeadBandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinSetpointDeadBandAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinSetpointDeadBandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemoteSensingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRemoteSensingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRemoteSensingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readControlSequenceOfOperationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeControlSequenceOfOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeControlSequenceOfOperationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSystemModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSystemModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSystemModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readThermostatRunningModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeThermostatRunningModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartOfWeekAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStartOfWeekAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfDailyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfDailyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTemperatureSetpointHoldAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureSetpointHoldAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureSetpointHoldAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTemperatureSetpointHoldDurationAttribute(long chipClusterPtr, + TemperatureSetpointHoldDurationAttributeCallback callback + ); + + private native void writeTemperatureSetpointHoldDurationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureSetpointHoldDurationAttribute(long chipClusterPtr, + TemperatureSetpointHoldDurationAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readThermostatProgrammingOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeThermostatProgrammingOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeThermostatProgrammingOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readThermostatRunningStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeThermostatRunningStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSetpointChangeSourceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSetpointChangeSourceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSetpointChangeAmountAttribute(long chipClusterPtr, + SetpointChangeAmountAttributeCallback callback + ); + private native void subscribeSetpointChangeAmountAttribute(long chipClusterPtr, + SetpointChangeAmountAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSetpointChangeSourceTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSetpointChangeSourceTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedSetbackAttribute(long chipClusterPtr, + OccupiedSetbackAttributeCallback callback + ); + + private native void writeOccupiedSetbackAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedSetbackAttribute(long chipClusterPtr, + OccupiedSetbackAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOccupiedSetbackMinAttribute(long chipClusterPtr, + OccupiedSetbackMinAttributeCallback callback + ); + private native void subscribeOccupiedSetbackMinAttribute(long chipClusterPtr, + OccupiedSetbackMinAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOccupiedSetbackMaxAttribute(long chipClusterPtr, + OccupiedSetbackMaxAttributeCallback callback + ); + private native void subscribeOccupiedSetbackMaxAttribute(long chipClusterPtr, + OccupiedSetbackMaxAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readUnoccupiedSetbackAttribute(long chipClusterPtr, + UnoccupiedSetbackAttributeCallback callback + ); + + private native void writeUnoccupiedSetbackAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUnoccupiedSetbackAttribute(long chipClusterPtr, + UnoccupiedSetbackAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readUnoccupiedSetbackMinAttribute(long chipClusterPtr, + UnoccupiedSetbackMinAttributeCallback callback + ); + private native void subscribeUnoccupiedSetbackMinAttribute(long chipClusterPtr, + UnoccupiedSetbackMinAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readUnoccupiedSetbackMaxAttribute(long chipClusterPtr, + UnoccupiedSetbackMaxAttributeCallback callback + ); + private native void subscribeUnoccupiedSetbackMaxAttribute(long chipClusterPtr, + UnoccupiedSetbackMaxAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEmergencyHeatDeltaAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEmergencyHeatDeltaAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEmergencyHeatDeltaAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeACTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeACCapacityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACRefrigerantTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeACRefrigerantTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACRefrigerantTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACCompressorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeACCompressorTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACCompressorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACErrorCodeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeACErrorCodeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACErrorCodeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACLouverPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeACLouverPositionAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACLouverPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readACCoilTemperatureAttribute(long chipClusterPtr, + ACCoilTemperatureAttributeCallback callback + ); + private native void subscribeACCoilTemperatureAttribute(long chipClusterPtr, + ACCoilTemperatureAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readACCapacityformatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeACCapacityformatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeACCapacityformatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class FanControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000202L; + + public FanControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void step(DefaultClusterCallback callback + , Integer direction, Optional wrap, Optional lowestOff) { + step(chipClusterPtr, callback, direction, wrap, lowestOff, null); + } + + public void step(DefaultClusterCallback callback + , Integer direction, Optional wrap, Optional lowestOff + , int timedInvokeTimeoutMs) { + step(chipClusterPtr, callback, direction, wrap, lowestOff, timedInvokeTimeoutMs); + } + private native void step(long chipClusterPtr, DefaultClusterCallback Callback + , Integer direction, Optional wrap, Optional lowestOff + , @Nullable Integer timedInvokeTimeoutMs); + + public interface PercentSettingAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SpeedSettingAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readFanModeAttribute( + IntegerAttributeCallback callback + ) { + readFanModeAttribute(chipClusterPtr, callback); + } + public void writeFanModeAttribute(DefaultClusterCallback callback, Integer value) { + writeFanModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeFanModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeFanModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeFanModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFanModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFanModeSequenceAttribute( + IntegerAttributeCallback callback + ) { + readFanModeSequenceAttribute(chipClusterPtr, callback); + } + public void writeFanModeSequenceAttribute(DefaultClusterCallback callback, Integer value) { + writeFanModeSequenceAttribute(chipClusterPtr, callback, value, null); + } + + public void writeFanModeSequenceAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeFanModeSequenceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeFanModeSequenceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFanModeSequenceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPercentSettingAttribute( + PercentSettingAttributeCallback callback + ) { + readPercentSettingAttribute(chipClusterPtr, callback); + } + public void writePercentSettingAttribute(DefaultClusterCallback callback, Integer value) { + writePercentSettingAttribute(chipClusterPtr, callback, value, null); + } + + public void writePercentSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePercentSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePercentSettingAttribute( + PercentSettingAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePercentSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPercentCurrentAttribute( + IntegerAttributeCallback callback + ) { + readPercentCurrentAttribute(chipClusterPtr, callback); + } + public void subscribePercentCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePercentCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSpeedMaxAttribute( + IntegerAttributeCallback callback + ) { + readSpeedMaxAttribute(chipClusterPtr, callback); + } + public void subscribeSpeedMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSpeedMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSpeedSettingAttribute( + SpeedSettingAttributeCallback callback + ) { + readSpeedSettingAttribute(chipClusterPtr, callback); + } + public void writeSpeedSettingAttribute(DefaultClusterCallback callback, Integer value) { + writeSpeedSettingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSpeedSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeSpeedSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSpeedSettingAttribute( + SpeedSettingAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSpeedSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSpeedCurrentAttribute( + IntegerAttributeCallback callback + ) { + readSpeedCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeSpeedCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSpeedCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRockSupportAttribute( + IntegerAttributeCallback callback + ) { + readRockSupportAttribute(chipClusterPtr, callback); + } + public void subscribeRockSupportAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRockSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRockSettingAttribute( + IntegerAttributeCallback callback + ) { + readRockSettingAttribute(chipClusterPtr, callback); + } + public void writeRockSettingAttribute(DefaultClusterCallback callback, Integer value) { + writeRockSettingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRockSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRockSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRockSettingAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRockSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWindSupportAttribute( + IntegerAttributeCallback callback + ) { + readWindSupportAttribute(chipClusterPtr, callback); + } + public void subscribeWindSupportAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWindSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWindSettingAttribute( + IntegerAttributeCallback callback + ) { + readWindSettingAttribute(chipClusterPtr, callback); + } + public void writeWindSettingAttribute(DefaultClusterCallback callback, Integer value) { + writeWindSettingAttribute(chipClusterPtr, callback, value, null); + } + + public void writeWindSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeWindSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeWindSettingAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWindSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAirflowDirectionAttribute( + IntegerAttributeCallback callback + ) { + readAirflowDirectionAttribute(chipClusterPtr, callback); + } + public void writeAirflowDirectionAttribute(DefaultClusterCallback callback, Integer value) { + writeAirflowDirectionAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAirflowDirectionAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeAirflowDirectionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAirflowDirectionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAirflowDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readFanModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeFanModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFanModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFanModeSequenceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeFanModeSequenceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFanModeSequenceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPercentSettingAttribute(long chipClusterPtr, + PercentSettingAttributeCallback callback + ); + + private native void writePercentSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePercentSettingAttribute(long chipClusterPtr, + PercentSettingAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPercentCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePercentCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSpeedMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSpeedMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSpeedSettingAttribute(long chipClusterPtr, + SpeedSettingAttributeCallback callback + ); + + private native void writeSpeedSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSpeedSettingAttribute(long chipClusterPtr, + SpeedSettingAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSpeedCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSpeedCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRockSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRockSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRockSettingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRockSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRockSettingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWindSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWindSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWindSettingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWindSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWindSettingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAirflowDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeAirflowDirectionAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAirflowDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000204L; + + public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readTemperatureDisplayModeAttribute( + IntegerAttributeCallback callback + ) { + readTemperatureDisplayModeAttribute(chipClusterPtr, callback); + } + public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) { + writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeTemperatureDisplayModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readKeypadLockoutAttribute( + IntegerAttributeCallback callback + ) { + readKeypadLockoutAttribute(chipClusterPtr, callback); + } + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) { + writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null); + } + + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeKeypadLockoutAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readScheduleProgrammingVisibilityAttribute( + IntegerAttributeCallback callback + ) { + readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback); + } + public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) { + writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null); + } + + public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeScheduleProgrammingVisibilityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readTemperatureDisplayModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureDisplayModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readKeypadLockoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ColorControlCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000300L; + + public ColorControlCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void moveToHue(DefaultClusterCallback callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToHue(DefaultClusterCallback callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); + } + + public void moveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToSaturation(DefaultClusterCallback callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToSaturation(DefaultClusterCallback callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveSaturation(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); + } + + public void moveSaturation(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepSaturation(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepSaturation(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToHueAndSaturation(DefaultClusterCallback callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToHueAndSaturation(DefaultClusterCallback callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToColor(DefaultClusterCallback callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToColor(DefaultClusterCallback callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveColor(DefaultClusterCallback callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) { + moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null); + } + + public void moveColor(DefaultClusterCallback callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepColor(DefaultClusterCallback callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepColor(DefaultClusterCallback callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToColorTemperature(DefaultClusterCallback callback + , Integer colorTemperatureMireds, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToColorTemperature(chipClusterPtr, callback, colorTemperatureMireds, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToColorTemperature(DefaultClusterCallback callback + , Integer colorTemperatureMireds, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToColorTemperature(chipClusterPtr, callback, colorTemperatureMireds, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveToHue(DefaultClusterCallback callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedMoveToHue(DefaultClusterCallback callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); + } + + public void enhancedMoveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedStepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedStepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void colorLoopSet(DefaultClusterCallback callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride) { + colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, null); + } + + public void colorLoopSet(DefaultClusterCallback callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stopMoveStep(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride) { + stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null); + } + + public void stopMoveStep(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveColorTemperature(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride) { + moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, null); + } + + public void moveColorTemperature(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepColorTemperature(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride) { + stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, null); + } + + public void stepColorTemperature(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + private native void moveToHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer colorTemperatureMireds, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void colorLoopSet(long chipClusterPtr, DefaultClusterCallback Callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + + public interface NumberOfPrimariesAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface Primary1IntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface Primary2IntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface Primary3IntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface Primary4IntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface Primary5IntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface Primary6IntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ColorPointRIntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ColorPointGIntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ColorPointBIntensityAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface StartUpColorTemperatureMiredsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readCurrentHueAttribute( + IntegerAttributeCallback callback + ) { + readCurrentHueAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentHueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentSaturationAttribute( + IntegerAttributeCallback callback + ) { + readCurrentSaturationAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentSaturationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRemainingTimeAttribute( + IntegerAttributeCallback callback + ) { + readRemainingTimeAttribute(chipClusterPtr, callback); + } + public void subscribeRemainingTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentXAttribute( + IntegerAttributeCallback callback + ) { + readCurrentXAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentXAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentYAttribute( + IntegerAttributeCallback callback + ) { + readCurrentYAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentYAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDriftCompensationAttribute( + IntegerAttributeCallback callback + ) { + readDriftCompensationAttribute(chipClusterPtr, callback); + } + public void subscribeDriftCompensationAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCompensationTextAttribute( + CharStringAttributeCallback callback + ) { + readCompensationTextAttribute(chipClusterPtr, callback); + } + public void subscribeCompensationTextAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorTemperatureMiredsAttribute( + IntegerAttributeCallback callback + ) { + readColorTemperatureMiredsAttribute(chipClusterPtr, callback); + } + public void subscribeColorTemperatureMiredsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorModeAttribute( + IntegerAttributeCallback callback + ) { + readColorModeAttribute(chipClusterPtr, callback); + } + public void subscribeColorModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOptionsAttribute( + IntegerAttributeCallback callback + ) { + readOptionsAttribute(chipClusterPtr, callback); + } + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { + writeOptionsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOptionsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNumberOfPrimariesAttribute( + NumberOfPrimariesAttributeCallback callback + ) { + readNumberOfPrimariesAttribute(chipClusterPtr, callback); + } + public void subscribeNumberOfPrimariesAttribute( + NumberOfPrimariesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary1XAttribute( + IntegerAttributeCallback callback + ) { + readPrimary1XAttribute(chipClusterPtr, callback); + } + public void subscribePrimary1XAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary1YAttribute( + IntegerAttributeCallback callback + ) { + readPrimary1YAttribute(chipClusterPtr, callback); + } + public void subscribePrimary1YAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary1IntensityAttribute( + Primary1IntensityAttributeCallback callback + ) { + readPrimary1IntensityAttribute(chipClusterPtr, callback); + } + public void subscribePrimary1IntensityAttribute( + Primary1IntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary2XAttribute( + IntegerAttributeCallback callback + ) { + readPrimary2XAttribute(chipClusterPtr, callback); + } + public void subscribePrimary2XAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary2YAttribute( + IntegerAttributeCallback callback + ) { + readPrimary2YAttribute(chipClusterPtr, callback); + } + public void subscribePrimary2YAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary2IntensityAttribute( + Primary2IntensityAttributeCallback callback + ) { + readPrimary2IntensityAttribute(chipClusterPtr, callback); + } + public void subscribePrimary2IntensityAttribute( + Primary2IntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary3XAttribute( + IntegerAttributeCallback callback + ) { + readPrimary3XAttribute(chipClusterPtr, callback); + } + public void subscribePrimary3XAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary3YAttribute( + IntegerAttributeCallback callback + ) { + readPrimary3YAttribute(chipClusterPtr, callback); + } + public void subscribePrimary3YAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary3IntensityAttribute( + Primary3IntensityAttributeCallback callback + ) { + readPrimary3IntensityAttribute(chipClusterPtr, callback); + } + public void subscribePrimary3IntensityAttribute( + Primary3IntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary4XAttribute( + IntegerAttributeCallback callback + ) { + readPrimary4XAttribute(chipClusterPtr, callback); + } + public void subscribePrimary4XAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary4YAttribute( + IntegerAttributeCallback callback + ) { + readPrimary4YAttribute(chipClusterPtr, callback); + } + public void subscribePrimary4YAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary4IntensityAttribute( + Primary4IntensityAttributeCallback callback + ) { + readPrimary4IntensityAttribute(chipClusterPtr, callback); + } + public void subscribePrimary4IntensityAttribute( + Primary4IntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary5XAttribute( + IntegerAttributeCallback callback + ) { + readPrimary5XAttribute(chipClusterPtr, callback); + } + public void subscribePrimary5XAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary5YAttribute( + IntegerAttributeCallback callback + ) { + readPrimary5YAttribute(chipClusterPtr, callback); + } + public void subscribePrimary5YAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary5IntensityAttribute( + Primary5IntensityAttributeCallback callback + ) { + readPrimary5IntensityAttribute(chipClusterPtr, callback); + } + public void subscribePrimary5IntensityAttribute( + Primary5IntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary6XAttribute( + IntegerAttributeCallback callback + ) { + readPrimary6XAttribute(chipClusterPtr, callback); + } + public void subscribePrimary6XAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary6YAttribute( + IntegerAttributeCallback callback + ) { + readPrimary6YAttribute(chipClusterPtr, callback); + } + public void subscribePrimary6YAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPrimary6IntensityAttribute( + Primary6IntensityAttributeCallback callback + ) { + readPrimary6IntensityAttribute(chipClusterPtr, callback); + } + public void subscribePrimary6IntensityAttribute( + Primary6IntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWhitePointXAttribute( + IntegerAttributeCallback callback + ) { + readWhitePointXAttribute(chipClusterPtr, callback); + } + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) { + writeWhitePointXAttribute(chipClusterPtr, callback, value, null); + } + + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeWhitePointXAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWhitePointYAttribute( + IntegerAttributeCallback callback + ) { + readWhitePointYAttribute(chipClusterPtr, callback); + } + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) { + writeWhitePointYAttribute(chipClusterPtr, callback, value, null); + } + + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeWhitePointYAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointRXAttribute( + IntegerAttributeCallback callback + ) { + readColorPointRXAttribute(chipClusterPtr, callback); + } + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointRXAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointRXAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointRYAttribute( + IntegerAttributeCallback callback + ) { + readColorPointRYAttribute(chipClusterPtr, callback); + } + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointRYAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointRYAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointRIntensityAttribute( + ColorPointRIntensityAttributeCallback callback + ) { + readColorPointRIntensityAttribute(chipClusterPtr, callback); + } + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointRIntensityAttribute( + ColorPointRIntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointGXAttribute( + IntegerAttributeCallback callback + ) { + readColorPointGXAttribute(chipClusterPtr, callback); + } + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointGXAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointGXAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointGYAttribute( + IntegerAttributeCallback callback + ) { + readColorPointGYAttribute(chipClusterPtr, callback); + } + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointGYAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointGYAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointGIntensityAttribute( + ColorPointGIntensityAttributeCallback callback + ) { + readColorPointGIntensityAttribute(chipClusterPtr, callback); + } + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointGIntensityAttribute( + ColorPointGIntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointBXAttribute( + IntegerAttributeCallback callback + ) { + readColorPointBXAttribute(chipClusterPtr, callback); + } + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointBXAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointBXAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointBYAttribute( + IntegerAttributeCallback callback + ) { + readColorPointBYAttribute(chipClusterPtr, callback); + } + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointBYAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointBYAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorPointBIntensityAttribute( + ColorPointBIntensityAttributeCallback callback + ) { + readColorPointBIntensityAttribute(chipClusterPtr, callback); + } + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) { + writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null); + } + + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeColorPointBIntensityAttribute( + ColorPointBIntensityAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnhancedCurrentHueAttribute( + IntegerAttributeCallback callback + ) { + readEnhancedCurrentHueAttribute(chipClusterPtr, callback); + } + public void subscribeEnhancedCurrentHueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnhancedColorModeAttribute( + IntegerAttributeCallback callback + ) { + readEnhancedColorModeAttribute(chipClusterPtr, callback); + } + public void subscribeEnhancedColorModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorLoopActiveAttribute( + IntegerAttributeCallback callback + ) { + readColorLoopActiveAttribute(chipClusterPtr, callback); + } + public void subscribeColorLoopActiveAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorLoopDirectionAttribute( + IntegerAttributeCallback callback + ) { + readColorLoopDirectionAttribute(chipClusterPtr, callback); + } + public void subscribeColorLoopDirectionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorLoopTimeAttribute( + IntegerAttributeCallback callback + ) { + readColorLoopTimeAttribute(chipClusterPtr, callback); + } + public void subscribeColorLoopTimeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorLoopStartEnhancedHueAttribute( + IntegerAttributeCallback callback + ) { + readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback); + } + public void subscribeColorLoopStartEnhancedHueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorLoopStoredEnhancedHueAttribute( + IntegerAttributeCallback callback + ) { + readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback); + } + public void subscribeColorLoopStoredEnhancedHueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorCapabilitiesAttribute( + IntegerAttributeCallback callback + ) { + readColorCapabilitiesAttribute(chipClusterPtr, callback); + } + public void subscribeColorCapabilitiesAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorTempPhysicalMinMiredsAttribute( + IntegerAttributeCallback callback + ) { + readColorTempPhysicalMinMiredsAttribute(chipClusterPtr, callback); + } + public void subscribeColorTempPhysicalMinMiredsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorTempPhysicalMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readColorTempPhysicalMaxMiredsAttribute( + IntegerAttributeCallback callback + ) { + readColorTempPhysicalMaxMiredsAttribute(chipClusterPtr, callback); + } + public void subscribeColorTempPhysicalMaxMiredsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorTempPhysicalMaxMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCoupleColorTempToLevelMinMiredsAttribute( + IntegerAttributeCallback callback + ) { + readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback); + } + public void subscribeCoupleColorTempToLevelMinMiredsAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartUpColorTemperatureMiredsAttribute( + StartUpColorTemperatureMiredsAttributeCallback callback + ) { + readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback); + } + public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) { + writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeStartUpColorTemperatureMiredsAttribute( + StartUpColorTemperatureMiredsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentSaturationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentSaturationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDriftCompensationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDriftCompensationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCompensationTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeCompensationTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTemperatureMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTemperatureMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfPrimariesAttribute(long chipClusterPtr, + NumberOfPrimariesAttributeCallback callback + ); + private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, + NumberOfPrimariesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPrimary1XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1IntensityAttribute(long chipClusterPtr, + Primary1IntensityAttributeCallback callback + ); + private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, + Primary1IntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPrimary2XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2IntensityAttribute(long chipClusterPtr, + Primary2IntensityAttributeCallback callback + ); + private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, + Primary2IntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPrimary3XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3IntensityAttribute(long chipClusterPtr, + Primary3IntensityAttributeCallback callback + ); + private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, + Primary3IntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPrimary4XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4IntensityAttribute(long chipClusterPtr, + Primary4IntensityAttributeCallback callback + ); + private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, + Primary4IntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPrimary5XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5IntensityAttribute(long chipClusterPtr, + Primary5IntensityAttributeCallback callback + ); + private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, + Primary5IntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPrimary6XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6IntensityAttribute(long chipClusterPtr, + Primary6IntensityAttributeCallback callback + ); + private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, + Primary6IntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWhitePointXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWhitePointXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWhitePointXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWhitePointYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWhitePointYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWhitePointYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRIntensityAttribute(long chipClusterPtr, + ColorPointRIntensityAttributeCallback callback + ); + + private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, + ColorPointRIntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readColorPointGXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGIntensityAttribute(long chipClusterPtr, + ColorPointGIntensityAttributeCallback callback + ); + + private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, + ColorPointGIntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readColorPointBXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBIntensityAttribute(long chipClusterPtr, + ColorPointBIntensityAttributeCallback callback + ); + + private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, + ColorPointBIntensityAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEnhancedCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEnhancedCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnhancedColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEnhancedColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopStartEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopStartEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTempPhysicalMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMaxMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTempPhysicalMaxMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, + StartUpColorTemperatureMiredsAttributeCallback callback + ); + + private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, + StartUpColorTemperatureMiredsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class BallastConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000301L; + + public BallastConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface IntrinsicBallastFactorAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface BallastFactorAdjustmentAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LampRatedHoursAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LampBurnHoursAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LampBurnHoursTripPointAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readPhysicalMinLevelAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalMinLevelAttribute(chipClusterPtr, callback); + } + public void subscribePhysicalMinLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhysicalMaxLevelAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalMaxLevelAttribute(chipClusterPtr, callback); + } + public void subscribePhysicalMaxLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBallastStatusAttribute( + IntegerAttributeCallback callback + ) { + readBallastStatusAttribute(chipClusterPtr, callback); + } + public void subscribeBallastStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBallastStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinLevelAttribute( + IntegerAttributeCallback callback + ) { + readMinLevelAttribute(chipClusterPtr, callback); + } + public void writeMinLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeMinLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMinLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMinLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMinLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxLevelAttribute( + IntegerAttributeCallback callback + ) { + readMaxLevelAttribute(chipClusterPtr, callback); + } + public void writeMaxLevelAttribute(DefaultClusterCallback callback, Integer value) { + writeMaxLevelAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMaxLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeMaxLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeMaxLevelAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readIntrinsicBallastFactorAttribute( + IntrinsicBallastFactorAttributeCallback callback + ) { + readIntrinsicBallastFactorAttribute(chipClusterPtr, callback); + } + public void writeIntrinsicBallastFactorAttribute(DefaultClusterCallback callback, Integer value) { + writeIntrinsicBallastFactorAttribute(chipClusterPtr, callback, value, null); + } + + public void writeIntrinsicBallastFactorAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeIntrinsicBallastFactorAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeIntrinsicBallastFactorAttribute( + IntrinsicBallastFactorAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeIntrinsicBallastFactorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBallastFactorAdjustmentAttribute( + BallastFactorAdjustmentAttributeCallback callback + ) { + readBallastFactorAdjustmentAttribute(chipClusterPtr, callback); + } + public void writeBallastFactorAdjustmentAttribute(DefaultClusterCallback callback, Integer value) { + writeBallastFactorAdjustmentAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBallastFactorAdjustmentAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBallastFactorAdjustmentAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBallastFactorAdjustmentAttribute( + BallastFactorAdjustmentAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBallastFactorAdjustmentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampQuantityAttribute( + IntegerAttributeCallback callback + ) { + readLampQuantityAttribute(chipClusterPtr, callback); + } + public void subscribeLampQuantityAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLampQuantityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampTypeAttribute( + CharStringAttributeCallback callback + ) { + readLampTypeAttribute(chipClusterPtr, callback); + } + public void writeLampTypeAttribute(DefaultClusterCallback callback, String value) { + writeLampTypeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLampTypeAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeLampTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLampTypeAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLampTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampManufacturerAttribute( + CharStringAttributeCallback callback + ) { + readLampManufacturerAttribute(chipClusterPtr, callback); + } + public void writeLampManufacturerAttribute(DefaultClusterCallback callback, String value) { + writeLampManufacturerAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLampManufacturerAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeLampManufacturerAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLampManufacturerAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLampManufacturerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampRatedHoursAttribute( + LampRatedHoursAttributeCallback callback + ) { + readLampRatedHoursAttribute(chipClusterPtr, callback); + } + public void writeLampRatedHoursAttribute(DefaultClusterCallback callback, Long value) { + writeLampRatedHoursAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLampRatedHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLampRatedHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLampRatedHoursAttribute( + LampRatedHoursAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLampRatedHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampBurnHoursAttribute( + LampBurnHoursAttributeCallback callback + ) { + readLampBurnHoursAttribute(chipClusterPtr, callback); + } + public void writeLampBurnHoursAttribute(DefaultClusterCallback callback, Long value) { + writeLampBurnHoursAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLampBurnHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLampBurnHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLampBurnHoursAttribute( + LampBurnHoursAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLampBurnHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampAlarmModeAttribute( + IntegerAttributeCallback callback + ) { + readLampAlarmModeAttribute(chipClusterPtr, callback); + } + public void writeLampAlarmModeAttribute(DefaultClusterCallback callback, Integer value) { + writeLampAlarmModeAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLampAlarmModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeLampAlarmModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLampAlarmModeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLampAlarmModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLampBurnHoursTripPointAttribute( + LampBurnHoursTripPointAttributeCallback callback + ) { + readLampBurnHoursTripPointAttribute(chipClusterPtr, callback); + } + public void writeLampBurnHoursTripPointAttribute(DefaultClusterCallback callback, Long value) { + writeLampBurnHoursTripPointAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLampBurnHoursTripPointAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeLampBurnHoursTripPointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLampBurnHoursTripPointAttribute( + LampBurnHoursTripPointAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLampBurnHoursTripPointAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readPhysicalMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePhysicalMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhysicalMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePhysicalMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBallastStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBallastStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readIntrinsicBallastFactorAttribute(long chipClusterPtr, + IntrinsicBallastFactorAttributeCallback callback + ); + + private native void writeIntrinsicBallastFactorAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeIntrinsicBallastFactorAttribute(long chipClusterPtr, + IntrinsicBallastFactorAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBallastFactorAdjustmentAttribute(long chipClusterPtr, + BallastFactorAdjustmentAttributeCallback callback + ); + + private native void writeBallastFactorAdjustmentAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBallastFactorAdjustmentAttribute(long chipClusterPtr, + BallastFactorAdjustmentAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLampQuantityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLampQuantityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLampTypeAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLampTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLampTypeAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLampManufacturerAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLampManufacturerAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLampManufacturerAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLampRatedHoursAttribute(long chipClusterPtr, + LampRatedHoursAttributeCallback callback + ); + + private native void writeLampRatedHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLampRatedHoursAttribute(long chipClusterPtr, + LampRatedHoursAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLampBurnHoursAttribute(long chipClusterPtr, + LampBurnHoursAttributeCallback callback + ); + + private native void writeLampBurnHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLampBurnHoursAttribute(long chipClusterPtr, + LampBurnHoursAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLampAlarmModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeLampAlarmModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLampAlarmModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLampBurnHoursTripPointAttribute(long chipClusterPtr, + LampBurnHoursTripPointAttributeCallback callback + ); + + private native void writeLampBurnHoursTripPointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLampBurnHoursTripPointAttribute(long chipClusterPtr, + LampBurnHoursTripPointAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class IlluminanceMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000400L; + + public IlluminanceMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface LightSensorTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { + readToleranceAttribute(chipClusterPtr, callback); + } + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLightSensorTypeAttribute( + LightSensorTypeAttributeCallback callback + ) { + readLightSensorTypeAttribute(chipClusterPtr, callback); + } + public void subscribeLightSensorTypeAttribute( + LightSensorTypeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLightSensorTypeAttribute(long chipClusterPtr, + LightSensorTypeAttributeCallback callback + ); + private native void subscribeLightSensorTypeAttribute(long chipClusterPtr, + LightSensorTypeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class TemperatureMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000402L; + + public TemperatureMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { + readToleranceAttribute(chipClusterPtr, callback); + } + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class PressureMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000403L; + + public PressureMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ScaledValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinScaledValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxScaledValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { + readToleranceAttribute(chipClusterPtr, callback); + } + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readScaledValueAttribute( + ScaledValueAttributeCallback callback + ) { + readScaledValueAttribute(chipClusterPtr, callback); + } + public void subscribeScaledValueAttribute( + ScaledValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeScaledValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinScaledValueAttribute( + MinScaledValueAttributeCallback callback + ) { + readMinScaledValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinScaledValueAttribute( + MinScaledValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinScaledValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxScaledValueAttribute( + MaxScaledValueAttributeCallback callback + ) { + readMaxScaledValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxScaledValueAttribute( + MaxScaledValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxScaledValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readScaledToleranceAttribute( + IntegerAttributeCallback callback + ) { + readScaledToleranceAttribute(chipClusterPtr, callback); + } + public void subscribeScaledToleranceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeScaledToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readScaleAttribute( + IntegerAttributeCallback callback + ) { + readScaleAttribute(chipClusterPtr, callback); + } + public void subscribeScaleAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeScaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readScaledValueAttribute(long chipClusterPtr, + ScaledValueAttributeCallback callback + ); + private native void subscribeScaledValueAttribute(long chipClusterPtr, + ScaledValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinScaledValueAttribute(long chipClusterPtr, + MinScaledValueAttributeCallback callback + ); + private native void subscribeMinScaledValueAttribute(long chipClusterPtr, + MinScaledValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxScaledValueAttribute(long chipClusterPtr, + MaxScaledValueAttributeCallback callback + ); + private native void subscribeMaxScaledValueAttribute(long chipClusterPtr, + MaxScaledValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readScaledToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeScaledToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readScaleAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeScaleAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class FlowMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000404L; + + public FlowMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { + readToleranceAttribute(chipClusterPtr, callback); + } + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RelativeHumidityMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000405L; + + public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { + readToleranceAttribute(chipClusterPtr, callback); + } + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OccupancySensingCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000406L; + + public OccupancySensingCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readOccupancyAttribute( + IntegerAttributeCallback callback + ) { + readOccupancyAttribute(chipClusterPtr, callback); + } + public void subscribeOccupancyAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupancySensorTypeAttribute( + IntegerAttributeCallback callback + ) { + readOccupancySensorTypeAttribute(chipClusterPtr, callback); + } + public void subscribeOccupancySensorTypeAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOccupancySensorTypeBitmapAttribute( + IntegerAttributeCallback callback + ) { + readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback); + } + public void subscribeOccupancySensorTypeBitmapAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPIROccupiedToUnoccupiedDelayAttribute( + IntegerAttributeCallback callback + ) { + readPIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback); + } + public void writePIROccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) { + writePIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, null); + } + + public void writePIROccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePIROccupiedToUnoccupiedDelayAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPIRUnoccupiedToOccupiedDelayAttribute( + IntegerAttributeCallback callback + ) { + readPIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback); + } + public void writePIRUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) { + writePIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, null); + } + + public void writePIRUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePIRUnoccupiedToOccupiedDelayAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPIRUnoccupiedToOccupiedThresholdAttribute( + IntegerAttributeCallback callback + ) { + readPIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback); + } + public void writePIRUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value) { + writePIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, null); + } + + public void writePIRUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePIRUnoccupiedToOccupiedThresholdAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUltrasonicOccupiedToUnoccupiedDelayAttribute( + IntegerAttributeCallback callback + ) { + readUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback); + } + public void writeUltrasonicOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) { + writeUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUltrasonicOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUltrasonicOccupiedToUnoccupiedDelayAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUltrasonicUnoccupiedToOccupiedDelayAttribute( + IntegerAttributeCallback callback + ) { + readUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback); + } + public void writeUltrasonicUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) { + writeUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUltrasonicUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUltrasonicUnoccupiedToOccupiedDelayAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUltrasonicUnoccupiedToOccupiedThresholdAttribute( + IntegerAttributeCallback callback + ) { + readUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback); + } + public void writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value) { + writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUltrasonicUnoccupiedToOccupiedThresholdAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhysicalContactOccupiedToUnoccupiedDelayAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback); + } + public void writePhysicalContactOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) { + writePhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, null); + } + + public void writePhysicalContactOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePhysicalContactOccupiedToUnoccupiedDelayAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhysicalContactUnoccupiedToOccupiedDelayAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback); + } + public void writePhysicalContactUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) { + writePhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, null); + } + + public void writePhysicalContactUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePhysicalContactUnoccupiedToOccupiedDelayAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhysicalContactUnoccupiedToOccupiedThresholdAttribute( + IntegerAttributeCallback callback + ) { + readPhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback); + } + public void writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value) { + writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, null); + } + + public void writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribePhysicalContactUnoccupiedToOccupiedThresholdAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancySensorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeBitmapAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancySensorTypeBitmapAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPIROccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writePIROccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePIROccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPIRUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writePIRUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePIRUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPIRUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writePIRUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePIRUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUltrasonicOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeUltrasonicOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUltrasonicOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUltrasonicUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeUltrasonicUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUltrasonicUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUltrasonicUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUltrasonicUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhysicalContactOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writePhysicalContactOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePhysicalContactOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhysicalContactUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writePhysicalContactUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePhysicalContactUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhysicalContactUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePhysicalContactUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class CarbonMonoxideConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000040CL; + + public CarbonMonoxideConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class CarbonDioxideConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000040DL; + + public CarbonDioxideConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class NitrogenDioxideConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000413L; + + public NitrogenDioxideConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class OzoneConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000415L; + + public OzoneConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class Pm25ConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000042AL; + + public Pm25ConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class FormaldehydeConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000042BL; + + public FormaldehydeConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class Pm1ConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000042CL; + + public Pm1ConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class Pm10ConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000042DL; + + public Pm10ConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class TotalVolatileOrganicCompoundsConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000042EL; + + public TotalVolatileOrganicCompoundsConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class RadonConcentrationMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000042FL; + + public RadonConcentrationMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface PeakMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AverageMeasuredValueAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + ) { + readPeakMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueAttribute( + PeakMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPeakMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribePeakMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + ) { + readAverageMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueAttribute( + AverageMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback + ) { + readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback); + } + public void subscribeAverageMeasuredValueWindowAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUncertaintyAttribute( + FloatAttributeCallback callback + ) { + readUncertaintyAttribute(chipClusterPtr, callback); + } + public void subscribeUncertaintyAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementUnitAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementUnitAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementUnitAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasurementMediumAttribute( + IntegerAttributeCallback callback + ) { + readMeasurementMediumAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementMediumAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLevelValueAttribute( + IntegerAttributeCallback callback + ) { + readLevelValueAttribute(chipClusterPtr, callback); + } + public void subscribeLevelValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + ); + private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, + PeakMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, + AverageMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribeUncertaintyAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLevelValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class WakeOnLanCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000503L; + + public WakeOnLanCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMACAddressAttribute( + CharStringAttributeCallback callback + ) { + readMACAddressAttribute(chipClusterPtr, callback); + } + public void subscribeMACAddressAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMACAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMACAddressAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeMACAddressAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ChannelCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000504L; + + public ChannelCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void changeChannel(ChangeChannelResponseCallback callback + , String match) { + changeChannel(chipClusterPtr, callback, match, null); + } + + public void changeChannel(ChangeChannelResponseCallback callback + , String match + , int timedInvokeTimeoutMs) { + changeChannel(chipClusterPtr, callback, match, timedInvokeTimeoutMs); + } + + public void changeChannelByNumber(DefaultClusterCallback callback + , Integer majorNumber, Integer minorNumber) { + changeChannelByNumber(chipClusterPtr, callback, majorNumber, minorNumber, null); + } + + public void changeChannelByNumber(DefaultClusterCallback callback + , Integer majorNumber, Integer minorNumber + , int timedInvokeTimeoutMs) { + changeChannelByNumber(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); + } + + public void skipChannel(DefaultClusterCallback callback + , Integer count) { + skipChannel(chipClusterPtr, callback, count, null); + } + + public void skipChannel(DefaultClusterCallback callback + , Integer count + , int timedInvokeTimeoutMs) { + skipChannel(chipClusterPtr, callback, count, timedInvokeTimeoutMs); + } + private native void changeChannel(long chipClusterPtr, ChangeChannelResponseCallback Callback + , String match + , @Nullable Integer timedInvokeTimeoutMs); + private native void changeChannelByNumber(long chipClusterPtr, DefaultClusterCallback Callback + , Integer majorNumber, Integer minorNumber + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipChannel(long chipClusterPtr, DefaultClusterCallback Callback + , Integer count + , @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeChannelResponseCallback { + void onSuccess(Integer status, Optional data); + + void onError(Exception error); + } + + + public interface ChannelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readChannelListAttribute( + ChannelListAttributeCallback callback + ) { + readChannelListAttribute(chipClusterPtr, callback); + } + public void subscribeChannelListAttribute( + ChannelListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readChannelListAttribute(long chipClusterPtr, + ChannelListAttributeCallback callback + ); + private native void subscribeChannelListAttribute(long chipClusterPtr, + ChannelListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class TargetNavigatorCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000505L; + + public TargetNavigatorCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void navigateTarget(NavigateTargetResponseCallback callback + , Integer target, Optional data) { + navigateTarget(chipClusterPtr, callback, target, data, null); + } + + public void navigateTarget(NavigateTargetResponseCallback callback + , Integer target, Optional data + , int timedInvokeTimeoutMs) { + navigateTarget(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs); + } + private native void navigateTarget(long chipClusterPtr, NavigateTargetResponseCallback Callback + , Integer target, Optional data + , @Nullable Integer timedInvokeTimeoutMs); + public interface NavigateTargetResponseCallback { + void onSuccess(Integer status, Optional data); + + void onError(Exception error); + } + + + public interface TargetListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readTargetListAttribute( + TargetListAttributeCallback callback + ) { + readTargetListAttribute(chipClusterPtr, callback); + } + public void subscribeTargetListAttribute( + TargetListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentTargetAttribute( + IntegerAttributeCallback callback + ) { + readCurrentTargetAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentTargetAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readTargetListAttribute(long chipClusterPtr, + TargetListAttributeCallback callback + ); + private native void subscribeTargetListAttribute(long chipClusterPtr, + TargetListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentTargetAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentTargetAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class MediaPlaybackCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000506L; + + public MediaPlaybackCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void play(PlaybackResponseCallback callback + ) { + play(chipClusterPtr, callback, null); + } + + public void play(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + play(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void pause(PlaybackResponseCallback callback + ) { + pause(chipClusterPtr, callback, null); + } + + public void pause(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + pause(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void stop(PlaybackResponseCallback callback + ) { + stop(chipClusterPtr, callback, null); + } + + public void stop(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void startOver(PlaybackResponseCallback callback + ) { + startOver(chipClusterPtr, callback, null); + } + + public void startOver(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + startOver(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void previous(PlaybackResponseCallback callback + ) { + previous(chipClusterPtr, callback, null); + } + + public void previous(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + previous(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void next(PlaybackResponseCallback callback + ) { + next(chipClusterPtr, callback, null); + } + + public void next(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + next(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void rewind(PlaybackResponseCallback callback + ) { + rewind(chipClusterPtr, callback, null); + } + + public void rewind(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + rewind(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void fastForward(PlaybackResponseCallback callback + ) { + fastForward(chipClusterPtr, callback, null); + } + + public void fastForward(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { + fastForward(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void skipForward(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds) { + skipForward(chipClusterPtr, callback, deltaPositionMilliseconds, null); + } + + public void skipForward(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds + , int timedInvokeTimeoutMs) { + skipForward(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + } + + public void skipBackward(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds) { + skipBackward(chipClusterPtr, callback, deltaPositionMilliseconds, null); + } + + public void skipBackward(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds + , int timedInvokeTimeoutMs) { + skipBackward(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + } + + public void seek(PlaybackResponseCallback callback + , Long position) { + seek(chipClusterPtr, callback, position, null); + } + + public void seek(PlaybackResponseCallback callback + , Long position + , int timedInvokeTimeoutMs) { + seek(chipClusterPtr, callback, position, timedInvokeTimeoutMs); + } + private native void play(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void pause(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void stop(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void startOver(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void previous(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void next(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void rewind(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void fastForward(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipForward(long chipClusterPtr, PlaybackResponseCallback Callback + , Long deltaPositionMilliseconds + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipBackward(long chipClusterPtr, PlaybackResponseCallback Callback + , Long deltaPositionMilliseconds + , @Nullable Integer timedInvokeTimeoutMs); + private native void seek(long chipClusterPtr, PlaybackResponseCallback Callback + , Long position + , @Nullable Integer timedInvokeTimeoutMs); + public interface PlaybackResponseCallback { + void onSuccess(Integer status, Optional data); + + void onError(Exception error); + } + + + public interface StartTimeAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface DurationAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SeekRangeEndAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface SeekRangeStartAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readCurrentStateAttribute( + IntegerAttributeCallback callback + ) { + readCurrentStateAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentStateAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStartTimeAttribute( + StartTimeAttributeCallback callback + ) { + readStartTimeAttribute(chipClusterPtr, callback); + } + public void subscribeStartTimeAttribute( + StartTimeAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDurationAttribute( + DurationAttributeCallback callback + ) { + readDurationAttribute(chipClusterPtr, callback); + } + public void subscribeDurationAttribute( + DurationAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPlaybackSpeedAttribute( + FloatAttributeCallback callback + ) { + readPlaybackSpeedAttribute(chipClusterPtr, callback); + } + public void subscribePlaybackSpeedAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSeekRangeEndAttribute( + SeekRangeEndAttributeCallback callback + ) { + readSeekRangeEndAttribute(chipClusterPtr, callback); + } + public void subscribeSeekRangeEndAttribute( + SeekRangeEndAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSeekRangeStartAttribute( + SeekRangeStartAttributeCallback callback + ) { + readSeekRangeStartAttribute(chipClusterPtr, callback); + } + public void subscribeSeekRangeStartAttribute( + SeekRangeStartAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readCurrentStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartTimeAttribute(long chipClusterPtr, + StartTimeAttributeCallback callback + ); + private native void subscribeStartTimeAttribute(long chipClusterPtr, + StartTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDurationAttribute(long chipClusterPtr, + DurationAttributeCallback callback + ); + private native void subscribeDurationAttribute(long chipClusterPtr, + DurationAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPlaybackSpeedAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribePlaybackSpeedAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSeekRangeEndAttribute(long chipClusterPtr, + SeekRangeEndAttributeCallback callback + ); + private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, + SeekRangeEndAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSeekRangeStartAttribute(long chipClusterPtr, + SeekRangeStartAttributeCallback callback + ); + private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, + SeekRangeStartAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class MediaInputCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000507L; + + public MediaInputCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void selectInput(DefaultClusterCallback callback + , Integer index) { + selectInput(chipClusterPtr, callback, index, null); + } + + public void selectInput(DefaultClusterCallback callback + , Integer index + , int timedInvokeTimeoutMs) { + selectInput(chipClusterPtr, callback, index, timedInvokeTimeoutMs); + } + + public void showInputStatus(DefaultClusterCallback callback + ) { + showInputStatus(chipClusterPtr, callback, null); + } + + public void showInputStatus(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + showInputStatus(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void hideInputStatus(DefaultClusterCallback callback + ) { + hideInputStatus(chipClusterPtr, callback, null); + } + + public void hideInputStatus(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + hideInputStatus(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void renameInput(DefaultClusterCallback callback + , Integer index, String name) { + renameInput(chipClusterPtr, callback, index, name, null); + } + + public void renameInput(DefaultClusterCallback callback + , Integer index, String name + , int timedInvokeTimeoutMs) { + renameInput(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); + } + private native void selectInput(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index + , @Nullable Integer timedInvokeTimeoutMs); + private native void showInputStatus(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void hideInputStatus(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void renameInput(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index, String name + , @Nullable Integer timedInvokeTimeoutMs); + + public interface InputListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readInputListAttribute( + InputListAttributeCallback callback + ) { + readInputListAttribute(chipClusterPtr, callback); + } + public void subscribeInputListAttribute( + InputListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentInputAttribute( + IntegerAttributeCallback callback + ) { + readCurrentInputAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentInputAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentInputAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readInputListAttribute(long chipClusterPtr, + InputListAttributeCallback callback + ); + private native void subscribeInputListAttribute(long chipClusterPtr, + InputListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentInputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentInputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class LowPowerCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000508L; + + public LowPowerCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void sleep(DefaultClusterCallback callback + ) { + sleep(chipClusterPtr, callback, null); + } + + public void sleep(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class KeypadInputCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000509L; + + public KeypadInputCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void sendKey(SendKeyResponseCallback callback + , Integer keyCode) { + sendKey(chipClusterPtr, callback, keyCode, null); + } + + public void sendKey(SendKeyResponseCallback callback + , Integer keyCode + , int timedInvokeTimeoutMs) { + sendKey(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs); + } + private native void sendKey(long chipClusterPtr, SendKeyResponseCallback Callback + , Integer keyCode + , @Nullable Integer timedInvokeTimeoutMs); + public interface SendKeyResponseCallback { + void onSuccess(Integer status); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ContentLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000050AL; + + public ContentLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void launchContent(LauncherResponseCallback callback + , ChipStructs.ContentLauncherClusterContentSearchStruct search, Boolean autoPlay, Optional data) { + launchContent(chipClusterPtr, callback, search, autoPlay, data, null); + } + + public void launchContent(LauncherResponseCallback callback + , ChipStructs.ContentLauncherClusterContentSearchStruct search, Boolean autoPlay, Optional data + , int timedInvokeTimeoutMs) { + launchContent(chipClusterPtr, callback, search, autoPlay, data, timedInvokeTimeoutMs); + } + + public void launchURL(LauncherResponseCallback callback + , String contentURL, Optional displayString, Optional brandingInformation) { + launchURL(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); + } + + public void launchURL(LauncherResponseCallback callback + , String contentURL, Optional displayString, Optional brandingInformation + , int timedInvokeTimeoutMs) { + launchURL(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs); + } + private native void launchContent(long chipClusterPtr, LauncherResponseCallback Callback + , ChipStructs.ContentLauncherClusterContentSearchStruct search, Boolean autoPlay, Optional data + , @Nullable Integer timedInvokeTimeoutMs); + private native void launchURL(long chipClusterPtr, LauncherResponseCallback Callback + , String contentURL, Optional displayString, Optional brandingInformation + , @Nullable Integer timedInvokeTimeoutMs); + public interface LauncherResponseCallback { + void onSuccess(Integer status, Optional data); + + void onError(Exception error); + } + + + public interface AcceptHeaderAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readAcceptHeaderAttribute( + AcceptHeaderAttributeCallback callback + ) { + readAcceptHeaderAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptHeaderAttribute( + AcceptHeaderAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptHeaderAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback + ) { + readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); + } + public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readAcceptHeaderAttribute(long chipClusterPtr, + AcceptHeaderAttributeCallback callback + ); + private native void subscribeAcceptHeaderAttribute(long chipClusterPtr, + AcceptHeaderAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeSupportedStreamingProtocolsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class AudioOutputCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000050BL; + + public AudioOutputCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void selectOutput(DefaultClusterCallback callback + , Integer index) { + selectOutput(chipClusterPtr, callback, index, null); + } + + public void selectOutput(DefaultClusterCallback callback + , Integer index + , int timedInvokeTimeoutMs) { + selectOutput(chipClusterPtr, callback, index, timedInvokeTimeoutMs); + } + + public void renameOutput(DefaultClusterCallback callback + , Integer index, String name) { + renameOutput(chipClusterPtr, callback, index, name, null); + } + + public void renameOutput(DefaultClusterCallback callback + , Integer index, String name + , int timedInvokeTimeoutMs) { + renameOutput(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); + } + private native void selectOutput(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index + , @Nullable Integer timedInvokeTimeoutMs); + private native void renameOutput(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index, String name + , @Nullable Integer timedInvokeTimeoutMs); + + public interface OutputListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readOutputListAttribute( + OutputListAttributeCallback callback + ) { + readOutputListAttribute(chipClusterPtr, callback); + } + public void subscribeOutputListAttribute( + OutputListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentOutputAttribute( + IntegerAttributeCallback callback + ) { + readCurrentOutputAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentOutputAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readOutputListAttribute(long chipClusterPtr, + OutputListAttributeCallback callback + ); + private native void subscribeOutputListAttribute(long chipClusterPtr, + OutputListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentOutputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentOutputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ApplicationLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000050CL; + + public ApplicationLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void launchApp(LauncherResponseCallback callback + , Optional application, Optional data) { + launchApp(chipClusterPtr, callback, application, data, null); + } + + public void launchApp(LauncherResponseCallback callback + , Optional application, Optional data + , int timedInvokeTimeoutMs) { + launchApp(chipClusterPtr, callback, application, data, timedInvokeTimeoutMs); + } + + public void stopApp(LauncherResponseCallback callback + , Optional application) { + stopApp(chipClusterPtr, callback, application, null); + } + + public void stopApp(LauncherResponseCallback callback + , Optional application + , int timedInvokeTimeoutMs) { + stopApp(chipClusterPtr, callback, application, timedInvokeTimeoutMs); + } + + public void hideApp(LauncherResponseCallback callback + , Optional application) { + hideApp(chipClusterPtr, callback, application, null); + } + + public void hideApp(LauncherResponseCallback callback + , Optional application + , int timedInvokeTimeoutMs) { + hideApp(chipClusterPtr, callback, application, timedInvokeTimeoutMs); + } + private native void launchApp(long chipClusterPtr, LauncherResponseCallback Callback + , Optional application, Optional data + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopApp(long chipClusterPtr, LauncherResponseCallback Callback + , Optional application + , @Nullable Integer timedInvokeTimeoutMs); + private native void hideApp(long chipClusterPtr, LauncherResponseCallback Callback + , Optional application + , @Nullable Integer timedInvokeTimeoutMs); + public interface LauncherResponseCallback { + void onSuccess(Integer status, Optional data); + + void onError(Exception error); + } + + + public interface CatalogListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readCatalogListAttribute( + CatalogListAttributeCallback callback + ) { + readCatalogListAttribute(chipClusterPtr, callback); + } + public void subscribeCatalogListAttribute( + CatalogListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCatalogListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readCatalogListAttribute(long chipClusterPtr, + CatalogListAttributeCallback callback + ); + private native void subscribeCatalogListAttribute(long chipClusterPtr, + CatalogListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ApplicationBasicCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000050DL; + + public ApplicationBasicCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface AllowedVendorListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { + readVendorNameAttribute(chipClusterPtr, callback); + } + public void subscribeVendorNameAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readVendorIDAttribute( + IntegerAttributeCallback callback + ) { + readVendorIDAttribute(chipClusterPtr, callback); + } + public void subscribeVendorIDAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readApplicationNameAttribute( + CharStringAttributeCallback callback + ) { + readApplicationNameAttribute(chipClusterPtr, callback); + } + public void subscribeApplicationNameAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readProductIDAttribute( + IntegerAttributeCallback callback + ) { + readProductIDAttribute(chipClusterPtr, callback); + } + public void subscribeProductIDAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStatusAttribute( + IntegerAttributeCallback callback + ) { + readStatusAttribute(chipClusterPtr, callback); + } + public void subscribeStatusAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readApplicationVersionAttribute( + CharStringAttributeCallback callback + ) { + readApplicationVersionAttribute(chipClusterPtr, callback); + } + public void subscribeApplicationVersionAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAllowedVendorListAttribute( + AllowedVendorListAttributeCallback callback + ) { + readAllowedVendorListAttribute(chipClusterPtr, callback); + } + public void subscribeAllowedVendorListAttribute( + AllowedVendorListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeVendorIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeApplicationNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationVersionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeApplicationVersionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAllowedVendorListAttribute(long chipClusterPtr, + AllowedVendorListAttributeCallback callback + ); + private native void subscribeAllowedVendorListAttribute(long chipClusterPtr, + AllowedVendorListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class AccountLoginCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x0000050EL; + + public AccountLoginCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + + public void getSetupPIN(GetSetupPINResponseCallback callback + , String tempAccountIdentifier + , int timedInvokeTimeoutMs) { + getSetupPIN(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs); + } + + + public void login(DefaultClusterCallback callback + , String tempAccountIdentifier, String setupPIN + , int timedInvokeTimeoutMs) { + login(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs); + } + + + public void logout(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + logout(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void getSetupPIN(long chipClusterPtr, GetSetupPINResponseCallback Callback + , String tempAccountIdentifier + , @Nullable Integer timedInvokeTimeoutMs); + private native void login(long chipClusterPtr, DefaultClusterCallback Callback + , String tempAccountIdentifier, String setupPIN + , @Nullable Integer timedInvokeTimeoutMs); + private native void logout(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface GetSetupPINResponseCallback { + void onSuccess(String setupPIN); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class ElectricalMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0x00000B04L; + + public ElectricalMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void getProfileInfoCommand(DefaultClusterCallback callback + ) { + getProfileInfoCommand(chipClusterPtr, callback, null); + } + + public void getProfileInfoCommand(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + getProfileInfoCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void getMeasurementProfileCommand(DefaultClusterCallback callback + , Integer attributeId, Long startTime, Integer numberOfIntervals) { + getMeasurementProfileCommand(chipClusterPtr, callback, attributeId, startTime, numberOfIntervals, null); + } + + public void getMeasurementProfileCommand(DefaultClusterCallback callback + , Integer attributeId, Long startTime, Integer numberOfIntervals + , int timedInvokeTimeoutMs) { + getMeasurementProfileCommand(chipClusterPtr, callback, attributeId, startTime, numberOfIntervals, timedInvokeTimeoutMs); + } + private native void getProfileInfoCommand(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void getMeasurementProfileCommand(long chipClusterPtr, DefaultClusterCallback Callback + , Integer attributeId, Long startTime, Integer numberOfIntervals + , @Nullable Integer timedInvokeTimeoutMs); + public interface GetProfileInfoResponseCommandCallback { + void onSuccess(Integer profileCount, Integer profileIntervalPeriod, Integer maxNumberOfIntervals, ArrayList listOfAttributes); + + void onError(Exception error); + } + + public interface GetMeasurementProfileResponseCommandCallback { + void onSuccess(Long startTime, Integer status, Integer profileIntervalPeriod, Integer numberOfIntervalsDelivered, Integer attributeId, ArrayList intervals); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readMeasurementTypeAttribute( + LongAttributeCallback callback + ) { + readMeasurementTypeAttribute(chipClusterPtr, callback); + } + public void subscribeMeasurementTypeAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcVoltageAttribute( + IntegerAttributeCallback callback + ) { + readDcVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeDcVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcVoltageMinAttribute( + IntegerAttributeCallback callback + ) { + readDcVoltageMinAttribute(chipClusterPtr, callback); + } + public void subscribeDcVoltageMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcVoltageMaxAttribute( + IntegerAttributeCallback callback + ) { + readDcVoltageMaxAttribute(chipClusterPtr, callback); + } + public void subscribeDcVoltageMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcCurrentAttribute( + IntegerAttributeCallback callback + ) { + readDcCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeDcCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcCurrentMinAttribute( + IntegerAttributeCallback callback + ) { + readDcCurrentMinAttribute(chipClusterPtr, callback); + } + public void subscribeDcCurrentMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcCurrentMaxAttribute( + IntegerAttributeCallback callback + ) { + readDcCurrentMaxAttribute(chipClusterPtr, callback); + } + public void subscribeDcCurrentMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcPowerAttribute( + IntegerAttributeCallback callback + ) { + readDcPowerAttribute(chipClusterPtr, callback); + } + public void subscribeDcPowerAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcPowerMinAttribute( + IntegerAttributeCallback callback + ) { + readDcPowerMinAttribute(chipClusterPtr, callback); + } + public void subscribeDcPowerMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcPowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcPowerMaxAttribute( + IntegerAttributeCallback callback + ) { + readDcPowerMaxAttribute(chipClusterPtr, callback); + } + public void subscribeDcPowerMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcPowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcVoltageMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readDcVoltageMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeDcVoltageMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcVoltageMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcVoltageDivisorAttribute( + IntegerAttributeCallback callback + ) { + readDcVoltageDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeDcVoltageDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcVoltageDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcCurrentMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readDcCurrentMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeDcCurrentMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcCurrentDivisorAttribute( + IntegerAttributeCallback callback + ) { + readDcCurrentDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeDcCurrentDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcCurrentDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcPowerMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readDcPowerMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeDcPowerMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcPowerMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readDcPowerDivisorAttribute( + IntegerAttributeCallback callback + ) { + readDcPowerDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeDcPowerDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeDcPowerDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcFrequencyAttribute( + IntegerAttributeCallback callback + ) { + readAcFrequencyAttribute(chipClusterPtr, callback); + } + public void subscribeAcFrequencyAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcFrequencyMinAttribute( + IntegerAttributeCallback callback + ) { + readAcFrequencyMinAttribute(chipClusterPtr, callback); + } + public void subscribeAcFrequencyMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcFrequencyMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcFrequencyMaxAttribute( + IntegerAttributeCallback callback + ) { + readAcFrequencyMaxAttribute(chipClusterPtr, callback); + } + public void subscribeAcFrequencyMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcFrequencyMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNeutralCurrentAttribute( + IntegerAttributeCallback callback + ) { + readNeutralCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeNeutralCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNeutralCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTotalActivePowerAttribute( + LongAttributeCallback callback + ) { + readTotalActivePowerAttribute(chipClusterPtr, callback); + } + public void subscribeTotalActivePowerAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTotalReactivePowerAttribute( + LongAttributeCallback callback + ) { + readTotalReactivePowerAttribute(chipClusterPtr, callback); + } + public void subscribeTotalReactivePowerAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTotalReactivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTotalApparentPowerAttribute( + LongAttributeCallback callback + ) { + readTotalApparentPowerAttribute(chipClusterPtr, callback); + } + public void subscribeTotalApparentPowerAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTotalApparentPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasured1stHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasured1stHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasured1stHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasured1stHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasured3rdHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasured3rdHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasured3rdHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasured3rdHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasured5thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasured5thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasured5thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasured5thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasured7thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasured7thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasured7thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasured7thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasured9thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasured9thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasured9thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasured9thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasured11thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasured11thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasured11thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasured11thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasuredPhase1stHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredPhase1stHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredPhase1stHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredPhase1stHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasuredPhase3rdHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredPhase3rdHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredPhase3rdHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredPhase3rdHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasuredPhase5thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredPhase5thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredPhase5thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredPhase5thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasuredPhase7thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredPhase7thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredPhase7thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredPhase7thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasuredPhase9thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredPhase9thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredPhase9thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredPhase9thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMeasuredPhase11thHarmonicCurrentAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredPhase11thHarmonicCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredPhase11thHarmonicCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredPhase11thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcFrequencyMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readAcFrequencyMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeAcFrequencyMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcFrequencyMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcFrequencyDivisorAttribute( + IntegerAttributeCallback callback + ) { + readAcFrequencyDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeAcFrequencyDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcFrequencyDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPowerMultiplierAttribute( + LongAttributeCallback callback + ) { + readPowerMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribePowerMultiplierAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePowerMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPowerDivisorAttribute( + LongAttributeCallback callback + ) { + readPowerDivisorAttribute(chipClusterPtr, callback); + } + public void subscribePowerDivisorAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePowerDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readHarmonicCurrentMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeHarmonicCurrentMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPhaseHarmonicCurrentMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readPhaseHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribePhaseHarmonicCurrentMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePhaseHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstantaneousVoltageAttribute( + IntegerAttributeCallback callback + ) { + readInstantaneousVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeInstantaneousVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstantaneousVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstantaneousLineCurrentAttribute( + IntegerAttributeCallback callback + ) { + readInstantaneousLineCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeInstantaneousLineCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstantaneousLineCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstantaneousActiveCurrentAttribute( + IntegerAttributeCallback callback + ) { + readInstantaneousActiveCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeInstantaneousActiveCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstantaneousActiveCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstantaneousReactiveCurrentAttribute( + IntegerAttributeCallback callback + ) { + readInstantaneousReactiveCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeInstantaneousReactiveCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstantaneousReactiveCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInstantaneousPowerAttribute( + IntegerAttributeCallback callback + ) { + readInstantaneousPowerAttribute(chipClusterPtr, callback); + } + public void subscribeInstantaneousPowerAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstantaneousPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageMinAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageMinAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageMaxAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageMaxAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentMinAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentMinAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentMaxAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentMaxAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerMinAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerMinAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerMinAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerMaxAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerMaxAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerMaxAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReactivePowerAttribute( + IntegerAttributeCallback callback + ) { + readReactivePowerAttribute(chipClusterPtr, callback); + } + public void subscribeReactivePowerAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReactivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readApparentPowerAttribute( + IntegerAttributeCallback callback + ) { + readApparentPowerAttribute(chipClusterPtr, callback); + } + public void subscribeApparentPowerAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeApparentPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPowerFactorAttribute( + IntegerAttributeCallback callback + ) { + readPowerFactorAttribute(chipClusterPtr, callback); + } + public void subscribePowerFactorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePowerFactorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsVoltageMeasurementPeriodAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback); + } + public void writeAverageRmsVoltageMeasurementPeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAverageRmsVoltageMeasurementPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAverageRmsVoltageMeasurementPeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsUnderVoltageCounterAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback); + } + public void writeAverageRmsUnderVoltageCounterAttribute(DefaultClusterCallback callback, Integer value) { + writeAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAverageRmsUnderVoltageCounterAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAverageRmsUnderVoltageCounterAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeOverVoltagePeriodAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback); + } + public void writeRmsExtremeOverVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRmsExtremeOverVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRmsExtremeOverVoltagePeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeUnderVoltagePeriodAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback); + } + public void writeRmsExtremeUnderVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRmsExtremeUnderVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRmsExtremeUnderVoltagePeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSagPeriodAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSagPeriodAttribute(chipClusterPtr, callback); + } + public void writeRmsVoltageSagPeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeRmsVoltageSagPeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRmsVoltageSagPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRmsVoltageSagPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRmsVoltageSagPeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSagPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSwellPeriodAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback); + } + public void writeRmsVoltageSwellPeriodAttribute(DefaultClusterCallback callback, Integer value) { + writeRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRmsVoltageSwellPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRmsVoltageSwellPeriodAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcVoltageMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readAcVoltageMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeAcVoltageMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcVoltageMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcVoltageDivisorAttribute( + IntegerAttributeCallback callback + ) { + readAcVoltageDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeAcVoltageDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcVoltageDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcCurrentMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readAcCurrentMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeAcCurrentMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcCurrentDivisorAttribute( + IntegerAttributeCallback callback + ) { + readAcCurrentDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeAcCurrentDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcCurrentDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcPowerMultiplierAttribute( + IntegerAttributeCallback callback + ) { + readAcPowerMultiplierAttribute(chipClusterPtr, callback); + } + public void subscribeAcPowerMultiplierAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcPowerMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcPowerDivisorAttribute( + IntegerAttributeCallback callback + ) { + readAcPowerDivisorAttribute(chipClusterPtr, callback); + } + public void subscribeAcPowerDivisorAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcPowerDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOverloadAlarmsMaskAttribute( + IntegerAttributeCallback callback + ) { + readOverloadAlarmsMaskAttribute(chipClusterPtr, callback); + } + public void writeOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value) { + writeOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOverloadAlarmsMaskAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOverloadAlarmsMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readVoltageOverloadAttribute( + IntegerAttributeCallback callback + ) { + readVoltageOverloadAttribute(chipClusterPtr, callback); + } + public void subscribeVoltageOverloadAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVoltageOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCurrentOverloadAttribute( + IntegerAttributeCallback callback + ) { + readCurrentOverloadAttribute(chipClusterPtr, callback); + } + public void subscribeCurrentOverloadAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcOverloadAlarmsMaskAttribute( + IntegerAttributeCallback callback + ) { + readAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback); + } + public void writeAcOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value) { + writeAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, null); + } + + public void writeAcOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeAcOverloadAlarmsMaskAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcVoltageOverloadAttribute( + IntegerAttributeCallback callback + ) { + readAcVoltageOverloadAttribute(chipClusterPtr, callback); + } + public void subscribeAcVoltageOverloadAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcVoltageOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcCurrentOverloadAttribute( + IntegerAttributeCallback callback + ) { + readAcCurrentOverloadAttribute(chipClusterPtr, callback); + } + public void subscribeAcCurrentOverloadAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcCurrentOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcActivePowerOverloadAttribute( + IntegerAttributeCallback callback + ) { + readAcActivePowerOverloadAttribute(chipClusterPtr, callback); + } + public void subscribeAcActivePowerOverloadAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcActivePowerOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcReactivePowerOverloadAttribute( + IntegerAttributeCallback callback + ) { + readAcReactivePowerOverloadAttribute(chipClusterPtr, callback); + } + public void subscribeAcReactivePowerOverloadAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAcReactivePowerOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsOverVoltageAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsOverVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsOverVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsOverVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsUnderVoltageAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsUnderVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsUnderVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsUnderVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeOverVoltageAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeOverVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeRmsExtremeOverVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeOverVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeUnderVoltageAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeUnderVoltageAttribute(chipClusterPtr, callback); + } + public void subscribeRmsExtremeUnderVoltageAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeUnderVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSagAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSagAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageSagAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSagAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSwellAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSwellAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageSwellAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSwellAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLineCurrentPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readLineCurrentPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeLineCurrentPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLineCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveCurrentPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readActiveCurrentPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeActiveCurrentPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReactiveCurrentPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readReactiveCurrentPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeReactiveCurrentPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReactiveCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltagePhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltagePhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltagePhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltagePhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageMinPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageMinPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageMinPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageMinPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageMaxPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageMaxPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageMaxPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageMaxPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentMinPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentMinPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentMinPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentMinPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentMaxPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentMaxPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentMaxPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentMaxPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerMinPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerMinPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerMinPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerMinPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerMaxPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerMaxPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerMaxPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerMaxPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReactivePowerPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readReactivePowerPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeReactivePowerPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReactivePowerPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readApparentPowerPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readApparentPowerPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeApparentPowerPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeApparentPowerPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPowerFactorPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readPowerFactorPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribePowerFactorPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePowerFactorPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsVoltageMeasurementPeriodPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsVoltageMeasurementPeriodPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsVoltageMeasurementPeriodPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsVoltageMeasurementPeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsOverVoltageCounterPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsOverVoltageCounterPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsOverVoltageCounterPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsOverVoltageCounterPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsUnderVoltageCounterPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsUnderVoltageCounterPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsUnderVoltageCounterPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsUnderVoltageCounterPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeOverVoltagePeriodPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeOverVoltagePeriodPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsExtremeOverVoltagePeriodPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeOverVoltagePeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeUnderVoltagePeriodPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeUnderVoltagePeriodPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsExtremeUnderVoltagePeriodPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeUnderVoltagePeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSagPeriodPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSagPeriodPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageSagPeriodPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSagPeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSwellPeriodPhaseBAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSwellPeriodPhaseBAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageSwellPeriodPhaseBAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSwellPeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLineCurrentPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readLineCurrentPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeLineCurrentPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLineCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveCurrentPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readActiveCurrentPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeActiveCurrentPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActiveCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReactiveCurrentPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readReactiveCurrentPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeReactiveCurrentPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReactiveCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltagePhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltagePhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltagePhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltagePhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageMinPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageMinPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageMinPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageMinPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageMaxPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageMaxPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageMaxPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageMaxPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentMinPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentMinPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentMinPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentMinPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsCurrentMaxPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsCurrentMaxPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsCurrentMaxPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsCurrentMaxPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerMinPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerMinPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerMinPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerMinPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActivePowerMaxPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readActivePowerMaxPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeActivePowerMaxPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeActivePowerMaxPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readReactivePowerPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readReactivePowerPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeReactivePowerPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeReactivePowerPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readApparentPowerPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readApparentPowerPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeApparentPowerPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeApparentPowerPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readPowerFactorPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readPowerFactorPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribePowerFactorPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribePowerFactorPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsVoltageMeasurementPeriodPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsVoltageMeasurementPeriodPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsVoltageMeasurementPeriodPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsVoltageMeasurementPeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsOverVoltageCounterPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsOverVoltageCounterPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsOverVoltageCounterPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsOverVoltageCounterPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAverageRmsUnderVoltageCounterPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readAverageRmsUnderVoltageCounterPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeAverageRmsUnderVoltageCounterPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeAverageRmsUnderVoltageCounterPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeOverVoltagePeriodPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeOverVoltagePeriodPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsExtremeOverVoltagePeriodPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeOverVoltagePeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsExtremeUnderVoltagePeriodPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsExtremeUnderVoltagePeriodPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsExtremeUnderVoltagePeriodPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsExtremeUnderVoltagePeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSagPeriodPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSagPeriodPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageSagPeriodPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSagPeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRmsVoltageSwellPeriodPhaseCAttribute( + IntegerAttributeCallback callback + ) { + readRmsVoltageSwellPeriodPhaseCAttribute(chipClusterPtr, callback); + } + public void subscribeRmsVoltageSwellPeriodPhaseCAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRmsVoltageSwellPeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readMeasurementTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcPowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcPowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcPowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcPowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcPowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcPowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcVoltageMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcVoltageMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcVoltageDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcVoltageDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcCurrentDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcCurrentDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcPowerMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcPowerMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDcPowerDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDcPowerDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcFrequencyMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcFrequencyMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcFrequencyMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcFrequencyMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNeutralCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNeutralCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalActivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalReactivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalReactivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalApparentPowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalApparentPowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasured1stHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasured1stHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasured3rdHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasured3rdHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasured5thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasured5thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasured7thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasured7thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasured9thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasured9thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasured11thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasured11thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasuredPhase1stHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredPhase1stHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasuredPhase3rdHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredPhase3rdHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasuredPhase5thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredPhase5thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasuredPhase7thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredPhase7thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasuredPhase9thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredPhase9thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeasuredPhase11thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredPhase11thHarmonicCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcFrequencyMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcFrequencyMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcFrequencyDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcFrequencyDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPowerMultiplierAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePowerMultiplierAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPowerDivisorAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePowerDivisorAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHarmonicCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeHarmonicCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPhaseHarmonicCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePhaseHarmonicCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstantaneousVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstantaneousVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstantaneousLineCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstantaneousLineCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstantaneousActiveCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstantaneousActiveCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstantaneousReactiveCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstantaneousReactiveCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstantaneousPowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstantaneousPowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReactivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeReactivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApparentPowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeApparentPowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPowerFactorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePowerFactorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsVoltageMeasurementPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeAverageRmsVoltageMeasurementPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAverageRmsVoltageMeasurementPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsUnderVoltageCounterAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeAverageRmsUnderVoltageCounterAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAverageRmsUnderVoltageCounterAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeOverVoltagePeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRmsExtremeOverVoltagePeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRmsExtremeOverVoltagePeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeUnderVoltagePeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRmsExtremeUnderVoltagePeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRmsExtremeUnderVoltagePeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSagPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRmsVoltageSagPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRmsVoltageSagPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSwellPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRmsVoltageSwellPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRmsVoltageSwellPeriodAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcVoltageMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcVoltageMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcVoltageDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcVoltageDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcCurrentMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcCurrentDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcCurrentDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcPowerMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcPowerMultiplierAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcPowerDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcPowerDivisorAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverloadAlarmsMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOverloadAlarmsMaskAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOverloadAlarmsMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVoltageOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeVoltageOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcOverloadAlarmsMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeAcOverloadAlarmsMaskAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAcOverloadAlarmsMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcVoltageOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcVoltageOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcCurrentOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcCurrentOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcActivePowerOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcActivePowerOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAcReactivePowerOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAcReactivePowerOverloadAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsOverVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsOverVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsUnderVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsUnderVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeOverVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsExtremeOverVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeUnderVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsExtremeUnderVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSagAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageSagAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSwellAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageSwellAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLineCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLineCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActiveCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReactiveCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeReactiveCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltagePhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltagePhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMinPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMinPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMaxPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMinPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMinPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMaxPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMinPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMinPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMaxPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMaxPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReactivePowerPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeReactivePowerPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApparentPowerPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeApparentPowerPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPowerFactorPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePowerFactorPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsVoltageMeasurementPeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsVoltageMeasurementPeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsOverVoltageCounterPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsOverVoltageCounterPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsUnderVoltageCounterPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsUnderVoltageCounterPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeOverVoltagePeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsExtremeOverVoltagePeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeUnderVoltagePeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsExtremeUnderVoltagePeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSagPeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageSagPeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSwellPeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageSwellPeriodPhaseBAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLineCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLineCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActiveCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReactiveCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeReactiveCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltagePhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltagePhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMinPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMinPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMaxPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMinPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMinPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMaxPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMinPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMinPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMaxPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMaxPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReactivePowerPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeReactivePowerPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApparentPowerPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeApparentPowerPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPowerFactorPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePowerFactorPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsVoltageMeasurementPeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsVoltageMeasurementPeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsOverVoltageCounterPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsOverVoltageCounterPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAverageRmsUnderVoltageCounterPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAverageRmsUnderVoltageCounterPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeOverVoltagePeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsExtremeOverVoltagePeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsExtremeUnderVoltagePeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsExtremeUnderVoltagePeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSagPeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageSagPeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageSwellPeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageSwellPeriodPhaseCAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class UnitTestingCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0xFFF1FC05L; + + public UnitTestingCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void test(DefaultClusterCallback callback + ) { + test(chipClusterPtr, callback, null); + } + + public void test(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + test(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testNotHandled(DefaultClusterCallback callback + ) { + testNotHandled(chipClusterPtr, callback, null); + } + + public void testNotHandled(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testSpecific(TestSpecificResponseCallback callback + ) { + testSpecific(chipClusterPtr, callback, null); + } + + public void testSpecific(TestSpecificResponseCallback callback + + , int timedInvokeTimeoutMs) { + testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testUnknownCommand(DefaultClusterCallback callback + ) { + testUnknownCommand(chipClusterPtr, callback, null); + } + + public void testUnknownCommand(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testAddArguments(TestAddArgumentsResponseCallback callback + , Integer arg1, Integer arg2) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testAddArguments(TestAddArgumentsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testSimpleArgumentRequest(TestSimpleArgumentResponseCallback callback + , Boolean arg1) { + testSimpleArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testSimpleArgumentRequest(TestSimpleArgumentResponseCallback callback + , Boolean arg1 + , int timedInvokeTimeoutMs) { + testSimpleArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testStructArrayArgumentRequest(TestStructArrayArgumentResponseCallback callback + , ArrayList arg1, ArrayList arg2, ArrayList arg3, ArrayList arg4, Integer arg5, Boolean arg6) { + testStructArrayArgumentRequest(chipClusterPtr, callback, arg1, arg2, arg3, arg4, arg5, arg6, null); + } + + public void testStructArrayArgumentRequest(TestStructArrayArgumentResponseCallback callback + , ArrayList arg1, ArrayList arg2, ArrayList arg3, ArrayList arg4, Integer arg5, Boolean arg6 + , int timedInvokeTimeoutMs) { + testStructArrayArgumentRequest(chipClusterPtr, callback, arg1, arg2, arg3, arg4, arg5, arg6, timedInvokeTimeoutMs); + } + + public void testStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.UnitTestingClusterSimpleStruct arg1) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.UnitTestingClusterSimpleStruct arg1 + , int timedInvokeTimeoutMs) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.UnitTestingClusterNestedStruct arg1) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.UnitTestingClusterNestedStruct arg1 + , int timedInvokeTimeoutMs) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListStructArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListStructArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListInt8UArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructListArgumentRequest(BooleanResponseCallback callback + , ChipStructs.UnitTestingClusterNestedStructList arg1) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructListArgumentRequest(BooleanResponseCallback callback + , ChipStructs.UnitTestingClusterNestedStructList arg1 + , int timedInvokeTimeoutMs) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback + , ArrayList arg1) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testEnumsRequest(TestEnumsResponseCallback callback + , Integer arg1, Integer arg2) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testEnumsRequest(TestEnumsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback + , @Nullable Optional arg1) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback + , @Nullable Optional arg1 + , int timedInvokeTimeoutMs) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testComplexNullableOptionalRequest(TestComplexNullableOptionalResponseCallback callback + , @Nullable Integer nullableInt, Optional optionalInt, @Nullable Optional nullableOptionalInt, @Nullable String nullableString, Optional optionalString, @Nullable Optional nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional optionalStruct, @Nullable Optional nullableOptionalStruct, @Nullable ArrayList nullableList, Optional> optionalList, @Nullable Optional> nullableOptionalList) { + testComplexNullableOptionalRequest(chipClusterPtr, callback, nullableInt, optionalInt, nullableOptionalInt, nullableString, optionalString, nullableOptionalString, nullableStruct, optionalStruct, nullableOptionalStruct, nullableList, optionalList, nullableOptionalList, null); + } + + public void testComplexNullableOptionalRequest(TestComplexNullableOptionalResponseCallback callback + , @Nullable Integer nullableInt, Optional optionalInt, @Nullable Optional nullableOptionalInt, @Nullable String nullableString, Optional optionalString, @Nullable Optional nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional optionalStruct, @Nullable Optional nullableOptionalStruct, @Nullable ArrayList nullableList, Optional> optionalList, @Nullable Optional> nullableOptionalList + , int timedInvokeTimeoutMs) { + testComplexNullableOptionalRequest(chipClusterPtr, callback, nullableInt, optionalInt, nullableOptionalInt, nullableString, optionalString, nullableOptionalString, nullableStruct, optionalStruct, nullableOptionalStruct, nullableList, optionalList, nullableOptionalList, timedInvokeTimeoutMs); + } + + public void simpleStructEchoRequest(SimpleStructResponseCallback callback + , ChipStructs.UnitTestingClusterSimpleStruct arg1) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); + } + + public void simpleStructEchoRequest(SimpleStructResponseCallback callback + , ChipStructs.UnitTestingClusterSimpleStruct arg1 + , int timedInvokeTimeoutMs) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + + public void timedInvokeRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback + , Optional arg1) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback + , Optional arg1 + , int timedInvokeTimeoutMs) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback + , Integer arg1, Integer arg2, Boolean arg3) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + } + + public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback + , Integer arg1, Integer arg2, Boolean arg3 + , int timedInvokeTimeoutMs) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); + } + + public void testEmitTestFabricScopedEventRequest(TestEmitTestFabricScopedEventResponseCallback callback + , Integer arg1) { + testEmitTestFabricScopedEventRequest(chipClusterPtr, callback, arg1, null); + } + + public void testEmitTestFabricScopedEventRequest(TestEmitTestFabricScopedEventResponseCallback callback + , Integer arg1 + , int timedInvokeTimeoutMs) { + testEmitTestFabricScopedEventRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + private native void test(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSimpleArgumentRequest(long chipClusterPtr, TestSimpleArgumentResponseCallback Callback + , Boolean arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testStructArrayArgumentRequest(long chipClusterPtr, TestStructArrayArgumentResponseCallback Callback + , ArrayList arg1, ArrayList arg2, ArrayList arg3, ArrayList arg4, Integer arg5, Boolean arg6 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.UnitTestingClusterSimpleStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.UnitTestingClusterNestedStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.UnitTestingClusterNestedStructList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback + , @Nullable Optional arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testComplexNullableOptionalRequest(long chipClusterPtr, TestComplexNullableOptionalResponseCallback Callback + , @Nullable Integer nullableInt, Optional optionalInt, @Nullable Optional nullableOptionalInt, @Nullable String nullableString, Optional optionalString, @Nullable Optional nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional optionalStruct, @Nullable Optional nullableOptionalStruct, @Nullable ArrayList nullableList, Optional> optionalList, @Nullable Optional> nullableOptionalList + , @Nullable Integer timedInvokeTimeoutMs); + private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback Callback + , ChipStructs.UnitTestingClusterSimpleStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Optional arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback Callback + , Integer arg1, Integer arg2, Boolean arg3 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEmitTestFabricScopedEventRequest(long chipClusterPtr, TestEmitTestFabricScopedEventResponseCallback Callback + , Integer arg1 + , @Nullable Integer timedInvokeTimeoutMs); + public interface TestSpecificResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface TestAddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface TestSimpleArgumentResponseCallback { + void onSuccess(Boolean returnValue); + + void onError(Exception error); + } + + public interface TestStructArrayArgumentResponseCallback { + void onSuccess(ArrayList arg1, ArrayList arg2, ArrayList arg3, ArrayList arg4, Integer arg5, Boolean arg6); + + void onError(Exception error); + } + + public interface TestListInt8UReverseResponseCallback { + void onSuccess(ArrayList arg1); + + void onError(Exception error); + } + + public interface TestEnumsResponseCallback { + void onSuccess(Integer arg1, Integer arg2); + + void onError(Exception error); + } + + public interface TestNullableOptionalResponseCallback { + void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); + + void onError(Exception error); + } + + public interface TestComplexNullableOptionalResponseCallback { + void onSuccess(Boolean nullableIntWasNull, Optional nullableIntValue, Boolean optionalIntWasPresent, Optional optionalIntValue, Boolean nullableOptionalIntWasPresent, Optional nullableOptionalIntWasNull, Optional nullableOptionalIntValue, Boolean nullableStringWasNull, Optional nullableStringValue, Boolean optionalStringWasPresent, Optional optionalStringValue, Boolean nullableOptionalStringWasPresent, Optional nullableOptionalStringWasNull, Optional nullableOptionalStringValue, Boolean nullableStructWasNull, Optional nullableStructValue, Boolean optionalStructWasPresent, Optional optionalStructValue, Boolean nullableOptionalStructWasPresent, Optional nullableOptionalStructWasNull, Optional nullableOptionalStructValue, Boolean nullableListWasNull, Optional> nullableListValue, Boolean optionalListWasPresent, Optional> optionalListValue, Boolean nullableOptionalListWasPresent, Optional nullableOptionalListWasNull, Optional> nullableOptionalListValue); + + void onError(Exception error); + } + + public interface BooleanResponseCallback { + void onSuccess(Boolean value); + + void onError(Exception error); + } + + public interface SimpleStructResponseCallback { + void onSuccess(ChipStructs.UnitTestingClusterSimpleStruct arg1); + + void onError(Exception error); + } + + public interface TestEmitTestEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); + } + + public interface TestEmitTestFabricScopedEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); + } + + + public interface ListInt8uAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ListOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ListStructOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ListNullablesAndOptionalsStructAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ListLongOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ListFabricScopedAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableBooleanAttributeCallback { + void onSuccess(@Nullable Boolean value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableBitmap8AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableBitmap16AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableBitmap32AttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableBitmap64AttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt32uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt64uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt32sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableInt64sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableEnum8AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableEnum16AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableOctetStringAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableCharStringAttributeCallback { + void onSuccess(@Nullable String value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableEnumAttrAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readBooleanAttribute( + BooleanAttributeCallback callback + ) { + readBooleanAttribute(chipClusterPtr, callback); + } + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) { + writeBooleanAttribute(chipClusterPtr, callback, value, null); + } + + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBooleanAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBitmap8Attribute( + IntegerAttributeCallback callback + ) { + readBitmap8Attribute(chipClusterPtr, callback); + } + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) { + writeBitmap8Attribute(chipClusterPtr, callback, value, null); + } + + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBitmap8Attribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBitmap16Attribute( + IntegerAttributeCallback callback + ) { + readBitmap16Attribute(chipClusterPtr, callback); + } + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) { + writeBitmap16Attribute(chipClusterPtr, callback, value, null); + } + + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBitmap16Attribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBitmap32Attribute( + LongAttributeCallback callback + ) { + readBitmap32Attribute(chipClusterPtr, callback); + } + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) { + writeBitmap32Attribute(chipClusterPtr, callback, value, null); + } + + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBitmap32Attribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readBitmap64Attribute( + LongAttributeCallback callback + ) { + readBitmap64Attribute(chipClusterPtr, callback); + } + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) { + writeBitmap64Attribute(chipClusterPtr, callback, value, null); + } + + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeBitmap64Attribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt8uAttribute( + IntegerAttributeCallback callback + ) { + readInt8uAttribute(chipClusterPtr, callback); + } + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) { + writeInt8uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt8uAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt16uAttribute( + IntegerAttributeCallback callback + ) { + readInt16uAttribute(chipClusterPtr, callback); + } + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) { + writeInt16uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt16uAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt24uAttribute( + LongAttributeCallback callback + ) { + readInt24uAttribute(chipClusterPtr, callback); + } + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { + writeInt24uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt24uAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt32uAttribute( + LongAttributeCallback callback + ) { + readInt32uAttribute(chipClusterPtr, callback); + } + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) { + writeInt32uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt32uAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt40uAttribute( + LongAttributeCallback callback + ) { + readInt40uAttribute(chipClusterPtr, callback); + } + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { + writeInt40uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt40uAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt48uAttribute( + LongAttributeCallback callback + ) { + readInt48uAttribute(chipClusterPtr, callback); + } + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { + writeInt48uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt48uAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt56uAttribute( + LongAttributeCallback callback + ) { + readInt56uAttribute(chipClusterPtr, callback); + } + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { + writeInt56uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt56uAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt64uAttribute( + LongAttributeCallback callback + ) { + readInt64uAttribute(chipClusterPtr, callback); + } + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) { + writeInt64uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt64uAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt8sAttribute( + IntegerAttributeCallback callback + ) { + readInt8sAttribute(chipClusterPtr, callback); + } + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) { + writeInt8sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt8sAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt16sAttribute( + IntegerAttributeCallback callback + ) { + readInt16sAttribute(chipClusterPtr, callback); + } + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) { + writeInt16sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt16sAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt24sAttribute( + LongAttributeCallback callback + ) { + readInt24sAttribute(chipClusterPtr, callback); + } + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { + writeInt24sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt24sAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt32sAttribute( + LongAttributeCallback callback + ) { + readInt32sAttribute(chipClusterPtr, callback); + } + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) { + writeInt32sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt32sAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt40sAttribute( + LongAttributeCallback callback + ) { + readInt40sAttribute(chipClusterPtr, callback); + } + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { + writeInt40sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt40sAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt48sAttribute( + LongAttributeCallback callback + ) { + readInt48sAttribute(chipClusterPtr, callback); + } + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { + writeInt48sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt48sAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt56sAttribute( + LongAttributeCallback callback + ) { + readInt56sAttribute(chipClusterPtr, callback); + } + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { + writeInt56sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt56sAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readInt64sAttribute( + LongAttributeCallback callback + ) { + readInt64sAttribute(chipClusterPtr, callback); + } + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) { + writeInt64sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeInt64sAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnum8Attribute( + IntegerAttributeCallback callback + ) { + readEnum8Attribute(chipClusterPtr, callback); + } + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) { + writeEnum8Attribute(chipClusterPtr, callback, value, null); + } + + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnum8Attribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnum16Attribute( + IntegerAttributeCallback callback + ) { + readEnum16Attribute(chipClusterPtr, callback); + } + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) { + writeEnum16Attribute(chipClusterPtr, callback, value, null); + } + + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnum16Attribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFloatSingleAttribute( + FloatAttributeCallback callback + ) { + readFloatSingleAttribute(chipClusterPtr, callback); + } + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { + writeFloatSingleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeFloatSingleAttribute( + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFloatDoubleAttribute( + DoubleAttributeCallback callback + ) { + readFloatDoubleAttribute(chipClusterPtr, callback); + } + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { + writeFloatDoubleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeFloatDoubleAttribute( + DoubleAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOctetStringAttribute( + OctetStringAttributeCallback callback + ) { + readOctetStringAttribute(chipClusterPtr, callback); + } + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { + writeOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeOctetStringAttribute( + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readListInt8uAttribute( + ListInt8uAttributeCallback callback + ) { + readListInt8uAttribute(chipClusterPtr, callback); + } + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value) { + writeListInt8uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListInt8uAttribute( + ListInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readListOctetStringAttribute( + ListOctetStringAttributeCallback callback + ) { + readListOctetStringAttribute(chipClusterPtr, callback); + } + public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + writeListOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListOctetStringAttribute( + ListOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readListStructOctetStringAttribute( + ListStructOctetStringAttributeCallback callback + ) { + readListStructOctetStringAttribute(chipClusterPtr, callback); + } + public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListStructOctetStringAttribute( + ListStructOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLongOctetStringAttribute( + OctetStringAttributeCallback callback + ) { + readLongOctetStringAttribute(chipClusterPtr, callback); + } + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { + writeLongOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLongOctetStringAttribute( + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readCharStringAttribute( + CharStringAttributeCallback callback + ) { + readCharStringAttribute(chipClusterPtr, callback); + } + public void writeCharStringAttribute(DefaultClusterCallback callback, String value) { + writeCharStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeCharStringAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLongCharStringAttribute( + CharStringAttributeCallback callback + ) { + readLongCharStringAttribute(chipClusterPtr, callback); + } + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) { + writeLongCharStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeLongCharStringAttribute( + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEpochUsAttribute( + LongAttributeCallback callback + ) { + readEpochUsAttribute(chipClusterPtr, callback); + } + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) { + writeEpochUsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEpochUsAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEpochSAttribute( + LongAttributeCallback callback + ) { + readEpochSAttribute(chipClusterPtr, callback); + } + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) { + writeEpochSAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEpochSAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readVendorIdAttribute( + IntegerAttributeCallback callback + ) { + readVendorIdAttribute(chipClusterPtr, callback); + } + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) { + writeVendorIdAttribute(chipClusterPtr, callback, value, null); + } + + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeVendorIdAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readListNullablesAndOptionalsStructAttribute( + ListNullablesAndOptionalsStructAttributeCallback callback + ) { + readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); + } + public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value) { + writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListNullablesAndOptionalsStructAttribute( + ListNullablesAndOptionalsStructAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEnumAttrAttribute( + IntegerAttributeCallback callback + ) { + readEnumAttrAttribute(chipClusterPtr, callback); + } + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { + writeEnumAttrAttribute(chipClusterPtr, callback, value, null); + } + + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeEnumAttrAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRangeRestrictedInt8uAttribute( + IntegerAttributeCallback callback + ) { + readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); + } + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRangeRestrictedInt8uAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRangeRestrictedInt8sAttribute( + IntegerAttributeCallback callback + ) { + readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); + } + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRangeRestrictedInt8sAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRangeRestrictedInt16uAttribute( + IntegerAttributeCallback callback + ) { + readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); + } + public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRangeRestrictedInt16uAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRangeRestrictedInt16sAttribute( + IntegerAttributeCallback callback + ) { + readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); + } + public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeRangeRestrictedInt16sAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readListLongOctetStringAttribute( + ListLongOctetStringAttributeCallback callback + ) { + readListLongOctetStringAttribute(chipClusterPtr, callback); + } + public void writeListLongOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + writeListLongOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListLongOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListLongOctetStringAttribute( + ListLongOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readListFabricScopedAttribute( + ListFabricScopedAttributeCallback callback + ) { + readListFabricScopedAttribute(chipClusterPtr, callback, true); + } + public void readListFabricScopedAttributeWithFabricFilter( + ListFabricScopedAttributeCallback callback + , + boolean isFabricFiltered + ) { + readListFabricScopedAttribute(chipClusterPtr, callback, isFabricFiltered); + } + public void writeListFabricScopedAttribute(DefaultClusterCallback callback, ArrayList value) { + writeListFabricScopedAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListFabricScopedAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListFabricScopedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListFabricScopedAttribute( + ListFabricScopedAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListFabricScopedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readTimedWriteBooleanAttribute( + BooleanAttributeCallback callback + ) { + readTimedWriteBooleanAttribute(chipClusterPtr, callback); + } + + public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeTimedWriteBooleanAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneralErrorBooleanAttribute( + BooleanAttributeCallback callback + ) { + readGeneralErrorBooleanAttribute(chipClusterPtr, callback); + } + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { + writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null); + } + + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeGeneralErrorBooleanAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterErrorBooleanAttribute( + BooleanAttributeCallback callback + ) { + readClusterErrorBooleanAttribute(chipClusterPtr, callback); + } + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { + writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null); + } + + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeClusterErrorBooleanAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUnsupportedAttribute( + BooleanAttributeCallback callback + ) { + readUnsupportedAttribute(chipClusterPtr, callback); + } + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) { + writeUnsupportedAttribute(chipClusterPtr, callback, value, null); + } + + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeUnsupportedAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableBooleanAttribute( + NullableBooleanAttributeCallback callback + ) { + readNullableBooleanAttribute(chipClusterPtr, callback); + } + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) { + writeNullableBooleanAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableBooleanAttribute( + NullableBooleanAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableBitmap8Attribute( + NullableBitmap8AttributeCallback callback + ) { + readNullableBitmap8Attribute(chipClusterPtr, callback); + } + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) { + writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableBitmap8Attribute( + NullableBitmap8AttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableBitmap16Attribute( + NullableBitmap16AttributeCallback callback + ) { + readNullableBitmap16Attribute(chipClusterPtr, callback); + } + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) { + writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableBitmap16Attribute( + NullableBitmap16AttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableBitmap32Attribute( + NullableBitmap32AttributeCallback callback + ) { + readNullableBitmap32Attribute(chipClusterPtr, callback); + } + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) { + writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableBitmap32Attribute( + NullableBitmap32AttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableBitmap64Attribute( + NullableBitmap64AttributeCallback callback + ) { + readNullableBitmap64Attribute(chipClusterPtr, callback); + } + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) { + writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableBitmap64Attribute( + NullableBitmap64AttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt8uAttribute( + NullableInt8uAttributeCallback callback + ) { + readNullableInt8uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableInt8uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt8uAttribute( + NullableInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt16uAttribute( + NullableInt16uAttributeCallback callback + ) { + readNullableInt16uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableInt16uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt16uAttribute( + NullableInt16uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt24uAttribute( + NullableInt24uAttributeCallback callback + ) { + readNullableInt24uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt24uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt24uAttribute( + NullableInt24uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt32uAttribute( + NullableInt32uAttributeCallback callback + ) { + readNullableInt32uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt32uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt32uAttribute( + NullableInt32uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt40uAttribute( + NullableInt40uAttributeCallback callback + ) { + readNullableInt40uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt40uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt40uAttribute( + NullableInt40uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt48uAttribute( + NullableInt48uAttributeCallback callback + ) { + readNullableInt48uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt48uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt48uAttribute( + NullableInt48uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt56uAttribute( + NullableInt56uAttributeCallback callback + ) { + readNullableInt56uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt56uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt56uAttribute( + NullableInt56uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt64uAttribute( + NullableInt64uAttributeCallback callback + ) { + readNullableInt64uAttribute(chipClusterPtr, callback); + } + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt64uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt64uAttribute( + NullableInt64uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt8sAttribute( + NullableInt8sAttributeCallback callback + ) { + readNullableInt8sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableInt8sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt8sAttribute( + NullableInt8sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt16sAttribute( + NullableInt16sAttributeCallback callback + ) { + readNullableInt16sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableInt16sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt16sAttribute( + NullableInt16sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt24sAttribute( + NullableInt24sAttributeCallback callback + ) { + readNullableInt24sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt24sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt24sAttribute( + NullableInt24sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt32sAttribute( + NullableInt32sAttributeCallback callback + ) { + readNullableInt32sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt32sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt32sAttribute( + NullableInt32sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt40sAttribute( + NullableInt40sAttributeCallback callback + ) { + readNullableInt40sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt40sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt40sAttribute( + NullableInt40sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt48sAttribute( + NullableInt48sAttributeCallback callback + ) { + readNullableInt48sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt48sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt48sAttribute( + NullableInt48sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt56sAttribute( + NullableInt56sAttributeCallback callback + ) { + readNullableInt56sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt56sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt56sAttribute( + NullableInt56sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableInt64sAttribute( + NullableInt64sAttributeCallback callback + ) { + readNullableInt64sAttribute(chipClusterPtr, callback); + } + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) { + writeNullableInt64sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableInt64sAttribute( + NullableInt64sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableEnum8Attribute( + NullableEnum8AttributeCallback callback + ) { + readNullableEnum8Attribute(chipClusterPtr, callback); + } + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) { + writeNullableEnum8Attribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableEnum8Attribute( + NullableEnum8AttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableEnum16Attribute( + NullableEnum16AttributeCallback callback + ) { + readNullableEnum16Attribute(chipClusterPtr, callback); + } + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) { + writeNullableEnum16Attribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableEnum16Attribute( + NullableEnum16AttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableFloatSingleAttribute( + NullableFloatSingleAttributeCallback callback + ) { + readNullableFloatSingleAttribute(chipClusterPtr, callback); + } + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) { + writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableFloatSingleAttribute( + NullableFloatSingleAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableFloatDoubleAttribute( + NullableFloatDoubleAttributeCallback callback + ) { + readNullableFloatDoubleAttribute(chipClusterPtr, callback); + } + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { + writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableFloatDoubleAttribute( + NullableFloatDoubleAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableOctetStringAttribute( + NullableOctetStringAttributeCallback callback + ) { + readNullableOctetStringAttribute(chipClusterPtr, callback); + } + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { + writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableOctetStringAttribute( + NullableOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableCharStringAttribute( + NullableCharStringAttributeCallback callback + ) { + readNullableCharStringAttribute(chipClusterPtr, callback); + } + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) { + writeNullableCharStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableCharStringAttribute( + NullableCharStringAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableEnumAttrAttribute( + NullableEnumAttrAttributeCallback callback + ) { + readNullableEnumAttrAttribute(chipClusterPtr, callback); + } + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableEnumAttrAttribute( + NullableEnumAttrAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableRangeRestrictedInt8uAttribute( + NullableRangeRestrictedInt8uAttributeCallback callback + ) { + readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); + } + public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableRangeRestrictedInt8uAttribute( + NullableRangeRestrictedInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableRangeRestrictedInt8sAttribute( + NullableRangeRestrictedInt8sAttributeCallback callback + ) { + readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); + } + public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableRangeRestrictedInt8sAttribute( + NullableRangeRestrictedInt8sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableRangeRestrictedInt16uAttribute( + NullableRangeRestrictedInt16uAttributeCallback callback + ) { + readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); + } + public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableRangeRestrictedInt16uAttribute( + NullableRangeRestrictedInt16uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readNullableRangeRestrictedInt16sAttribute( + NullableRangeRestrictedInt16sAttributeCallback callback + ) { + readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); + } + public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); + } + + public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeNullableRangeRestrictedInt16sAttribute( + NullableRangeRestrictedInt16sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readWriteOnlyInt8uAttribute( + IntegerAttributeCallback callback + ) { + readWriteOnlyInt8uAttribute(chipClusterPtr, callback); + } + public void writeWriteOnlyInt8uAttribute(DefaultClusterCallback callback, Integer value) { + writeWriteOnlyInt8uAttribute(chipClusterPtr, callback, value, null); + } + + public void writeWriteOnlyInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeWriteOnlyInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeWriteOnlyInt8uAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeWriteOnlyInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap32Attribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap32Attribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap64Attribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap64Attribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt24uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt24uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt32uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt32uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt40uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt40uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt48uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt48uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt56uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt56uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt64uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt64uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt24sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt24sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt32sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt32sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt40sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt40sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt48sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt48sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt56sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt56sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt64sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt64sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnum8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnum8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnum16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnum16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFloatSingleAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + + private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFloatSingleAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFloatDoubleAttribute(long chipClusterPtr, + DoubleAttributeCallback callback + ); + + private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFloatDoubleAttribute(long chipClusterPtr, + DoubleAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + + private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListInt8uAttribute(long chipClusterPtr, + ListInt8uAttributeCallback callback + ); + + private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListInt8uAttribute(long chipClusterPtr, + ListInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListOctetStringAttribute(long chipClusterPtr, + ListOctetStringAttributeCallback callback + ); + + private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListOctetStringAttribute(long chipClusterPtr, + ListOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListStructOctetStringAttribute(long chipClusterPtr, + ListStructOctetStringAttributeCallback callback + ); + + private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, + ListStructOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLongOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + + private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLongOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLongCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLongCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEpochUsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEpochUsAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEpochSAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEpochSAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback + ); + + private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEnumAttrAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnumAttrAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListLongOctetStringAttribute(long chipClusterPtr, + ListLongOctetStringAttributeCallback callback + ); + + private native void writeListLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, + ListLongOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListFabricScopedAttribute(long chipClusterPtr, + ListFabricScopedAttributeCallback callback + , boolean isFabricFiltered + ); + + private native void writeListFabricScopedAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListFabricScopedAttribute(long chipClusterPtr, + ListFabricScopedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTimedWriteBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUnsupportedAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUnsupportedAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNullableBooleanAttribute(long chipClusterPtr, + NullableBooleanAttributeCallback callback + ); + + private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBooleanAttribute(long chipClusterPtr, + NullableBooleanAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap8Attribute(long chipClusterPtr, + NullableBitmap8AttributeCallback callback + ); + + private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, + NullableBitmap8AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap16Attribute(long chipClusterPtr, + NullableBitmap16AttributeCallback callback + ); + + private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, + NullableBitmap16AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap32Attribute(long chipClusterPtr, + NullableBitmap32AttributeCallback callback + ); + + private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, + NullableBitmap32AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap64Attribute(long chipClusterPtr, + NullableBitmap64AttributeCallback callback + ); + + private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, + NullableBitmap64AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt8uAttribute(long chipClusterPtr, + NullableInt8uAttributeCallback callback + ); + + private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt8uAttribute(long chipClusterPtr, + NullableInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt16uAttribute(long chipClusterPtr, + NullableInt16uAttributeCallback callback + ); + + private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt16uAttribute(long chipClusterPtr, + NullableInt16uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt24uAttribute(long chipClusterPtr, + NullableInt24uAttributeCallback callback + ); + + private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt24uAttribute(long chipClusterPtr, + NullableInt24uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt32uAttribute(long chipClusterPtr, + NullableInt32uAttributeCallback callback + ); + + private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt32uAttribute(long chipClusterPtr, + NullableInt32uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt40uAttribute(long chipClusterPtr, + NullableInt40uAttributeCallback callback + ); + + private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt40uAttribute(long chipClusterPtr, + NullableInt40uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt48uAttribute(long chipClusterPtr, + NullableInt48uAttributeCallback callback + ); + + private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt48uAttribute(long chipClusterPtr, + NullableInt48uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt56uAttribute(long chipClusterPtr, + NullableInt56uAttributeCallback callback + ); + + private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt56uAttribute(long chipClusterPtr, + NullableInt56uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt64uAttribute(long chipClusterPtr, + NullableInt64uAttributeCallback callback + ); + + private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt64uAttribute(long chipClusterPtr, + NullableInt64uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt8sAttribute(long chipClusterPtr, + NullableInt8sAttributeCallback callback + ); + + private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt8sAttribute(long chipClusterPtr, + NullableInt8sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt16sAttribute(long chipClusterPtr, + NullableInt16sAttributeCallback callback + ); + + private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt16sAttribute(long chipClusterPtr, + NullableInt16sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt24sAttribute(long chipClusterPtr, + NullableInt24sAttributeCallback callback + ); + + private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt24sAttribute(long chipClusterPtr, + NullableInt24sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt32sAttribute(long chipClusterPtr, + NullableInt32sAttributeCallback callback + ); + + private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt32sAttribute(long chipClusterPtr, + NullableInt32sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt40sAttribute(long chipClusterPtr, + NullableInt40sAttributeCallback callback + ); + + private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt40sAttribute(long chipClusterPtr, + NullableInt40sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt48sAttribute(long chipClusterPtr, + NullableInt48sAttributeCallback callback + ); + + private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt48sAttribute(long chipClusterPtr, + NullableInt48sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt56sAttribute(long chipClusterPtr, + NullableInt56sAttributeCallback callback + ); + + private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt56sAttribute(long chipClusterPtr, + NullableInt56sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt64sAttribute(long chipClusterPtr, + NullableInt64sAttributeCallback callback + ); + + private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt64sAttribute(long chipClusterPtr, + NullableInt64sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnum8Attribute(long chipClusterPtr, + NullableEnum8AttributeCallback callback + ); + + private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnum8Attribute(long chipClusterPtr, + NullableEnum8AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnum16Attribute(long chipClusterPtr, + NullableEnum16AttributeCallback callback + ); + + private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnum16Attribute(long chipClusterPtr, + NullableEnum16AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableFloatSingleAttribute(long chipClusterPtr, + NullableFloatSingleAttributeCallback callback + ); + + private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, + NullableFloatSingleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableFloatDoubleAttribute(long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback + ); + + private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableOctetStringAttribute(long chipClusterPtr, + NullableOctetStringAttributeCallback callback + ); + + private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, + NullableOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableCharStringAttribute(long chipClusterPtr, + NullableCharStringAttributeCallback callback + ); + + private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableCharStringAttribute(long chipClusterPtr, + NullableCharStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnumAttrAttribute(long chipClusterPtr, + NullableEnumAttrAttributeCallback callback + ); + + private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, + NullableEnumAttrAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readWriteOnlyInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWriteOnlyInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWriteOnlyInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class FaultInjectionCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0xFFF1FC06L; + + public FaultInjectionCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void failAtFault(DefaultClusterCallback callback + , Integer type, Long id, Long numCallsToSkip, Long numCallsToFail, Boolean takeMutex) { + failAtFault(chipClusterPtr, callback, type, id, numCallsToSkip, numCallsToFail, takeMutex, null); + } + + public void failAtFault(DefaultClusterCallback callback + , Integer type, Long id, Long numCallsToSkip, Long numCallsToFail, Boolean takeMutex + , int timedInvokeTimeoutMs) { + failAtFault(chipClusterPtr, callback, type, id, numCallsToSkip, numCallsToFail, takeMutex, timedInvokeTimeoutMs); + } + + public void failRandomlyAtFault(DefaultClusterCallback callback + , Integer type, Long id, Integer percentage) { + failRandomlyAtFault(chipClusterPtr, callback, type, id, percentage, null); + } + + public void failRandomlyAtFault(DefaultClusterCallback callback + , Integer type, Long id, Integer percentage + , int timedInvokeTimeoutMs) { + failRandomlyAtFault(chipClusterPtr, callback, type, id, percentage, timedInvokeTimeoutMs); + } + private native void failAtFault(long chipClusterPtr, DefaultClusterCallback Callback + , Integer type, Long id, Long numCallsToSkip, Long numCallsToFail, Boolean takeMutex + , @Nullable Integer timedInvokeTimeoutMs); + private native void failRandomlyAtFault(long chipClusterPtr, DefaultClusterCallback Callback + , Integer type, Long id, Integer percentage + , @Nullable Integer timedInvokeTimeoutMs); + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } + + public static class SampleMeiCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 0xFFF1FC20L; + + public SampleMeiCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void ping(DefaultClusterCallback callback + ) { + ping(chipClusterPtr, callback, null); + } + + public void ping(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + ping(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void addArguments(AddArgumentsResponseCallback callback + , Integer arg1, Integer arg2) { + addArguments(chipClusterPtr, callback, arg1, arg2, null); + } + + public void addArguments(AddArgumentsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + addArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + private native void ping(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void addArguments(long chipClusterPtr, AddArgumentsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + public interface AddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + + public interface GeneratedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AcceptedCommandListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface EventListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + + public void readFlipFlopAttribute( + BooleanAttributeCallback callback + ) { + readFlipFlopAttribute(chipClusterPtr, callback); + } + public void writeFlipFlopAttribute(DefaultClusterCallback callback, Boolean value) { + writeFlipFlopAttribute(chipClusterPtr, callback, value, null); + } + + public void writeFlipFlopAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + writeFlipFlopAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeFlipFlopAttribute( + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFlipFlopAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + ) { + readGeneratedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeGeneratedCommandListAttribute( + GeneratedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + ) { + readAcceptedCommandListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptedCommandListAttribute( + AcceptedCommandListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readEventListAttribute( + EventListAttributeCallback callback + ) { + readEventListAttribute(chipClusterPtr, callback); + } + public void subscribeEventListAttribute( + EventListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + private native void readFlipFlopAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeFlipFlopAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFlipFlopAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + ); + private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, + GeneratedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + ); + private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, + AcceptedCommandListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + ); + private native void subscribeEventListAttribute(long chipClusterPtr, + EventListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeFeatureMapAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } +} + diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index cd139cb683e6e4..2ba9e12743ed48 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -5885,6 +5885,211 @@ class ChipClusters: }, }, } + _BOOLEAN_SENSOR_CONFIGURATION_CLUSTER_INFO = { + "clusterName": "BooleanSensorConfiguration", + "clusterId": 0x00000080, + "commands": { + 0x00000000: { + "commandId": 0x00000000, + "commandName": "SuppressRequest", + "args": { + "alarmsToSuppress": "int", + }, + }, + }, + "attributes": { + 0x00000000: { + "attributeName": "SensitivityLevel", + "attributeId": 0x00000000, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000001: { + "attributeName": "AlarmsActive", + "attributeId": 0x00000001, + "type": "int", + "reportable": True, + }, + 0x00000002: { + "attributeName": "AlarmsSuppressed", + "attributeId": 0x00000002, + "type": "int", + "reportable": True, + }, + 0x00000003: { + "attributeName": "AlarmsEnabled", + "attributeId": 0x00000003, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x0000FFF8: { + "attributeName": "GeneratedCommandList", + "attributeId": 0x0000FFF8, + "type": "int", + "reportable": True, + }, + 0x0000FFF9: { + "attributeName": "AcceptedCommandList", + "attributeId": 0x0000FFF9, + "type": "int", + "reportable": True, + }, + 0x0000FFFA: { + "attributeName": "EventList", + "attributeId": 0x0000FFFA, + "type": "int", + "reportable": True, + }, + 0x0000FFFB: { + "attributeName": "AttributeList", + "attributeId": 0x0000FFFB, + "type": "int", + "reportable": True, + }, + 0x0000FFFC: { + "attributeName": "FeatureMap", + "attributeId": 0x0000FFFC, + "type": "int", + "reportable": True, + }, + 0x0000FFFD: { + "attributeName": "ClusterRevision", + "attributeId": 0x0000FFFD, + "type": "int", + "reportable": True, + }, + }, + } + _VALVE_CONFIGURATION_AND_CONTROL_CLUSTER_INFO = { + "clusterName": "ValveConfigurationAndControl", + "clusterId": 0x00000081, + "commands": { + 0x00000000: { + "commandId": 0x00000000, + "commandName": "Open", + "args": { + "openDuration": "int", + }, + }, + 0x00000001: { + "commandId": 0x00000001, + "commandName": "Close", + "args": { + }, + }, + 0x00000002: { + "commandId": 0x00000002, + "commandName": "SetLevel", + "args": { + "level": "int", + "openDuration": "int", + }, + }, + }, + "attributes": { + 0x00000000: { + "attributeName": "OpenDuration", + "attributeId": 0x00000000, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000001: { + "attributeName": "AutoCloseTime", + "attributeId": 0x00000001, + "type": "int", + "reportable": True, + }, + 0x00000002: { + "attributeName": "RemainingDuration", + "attributeId": 0x00000002, + "type": "int", + "reportable": True, + }, + 0x00000003: { + "attributeName": "CurrentState", + "attributeId": 0x00000003, + "type": "int", + "reportable": True, + }, + 0x00000004: { + "attributeName": "TargetState", + "attributeId": 0x00000004, + "type": "int", + "reportable": True, + }, + 0x00000005: { + "attributeName": "StartUpState", + "attributeId": 0x00000005, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000006: { + "attributeName": "CurrentLevel", + "attributeId": 0x00000006, + "type": "int", + "reportable": True, + }, + 0x00000007: { + "attributeName": "TargetLevel", + "attributeId": 0x00000007, + "type": "int", + "reportable": True, + }, + 0x00000008: { + "attributeName": "OpenLevel", + "attributeId": 0x00000008, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000009: { + "attributeName": "ValveFault", + "attributeId": 0x00000009, + "type": "int", + "reportable": True, + }, + 0x0000FFF8: { + "attributeName": "GeneratedCommandList", + "attributeId": 0x0000FFF8, + "type": "int", + "reportable": True, + }, + 0x0000FFF9: { + "attributeName": "AcceptedCommandList", + "attributeId": 0x0000FFF9, + "type": "int", + "reportable": True, + }, + 0x0000FFFA: { + "attributeName": "EventList", + "attributeId": 0x0000FFFA, + "type": "int", + "reportable": True, + }, + 0x0000FFFB: { + "attributeName": "AttributeList", + "attributeId": 0x0000FFFB, + "type": "int", + "reportable": True, + }, + 0x0000FFFC: { + "attributeName": "FeatureMap", + "attributeId": 0x0000FFFC, + "type": "int", + "reportable": True, + }, + 0x0000FFFD: { + "attributeName": "ClusterRevision", + "attributeId": 0x0000FFFD, + "type": "int", + "reportable": True, + }, + }, + } _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO = { "clusterName": "DemandResponseLoadControl", "clusterId": 0x00000096, @@ -12633,6 +12838,8 @@ class ChipClusters: 0x00000061: _RVC_OPERATIONAL_STATE_CLUSTER_INFO, 0x00000071: _HEPA_FILTER_MONITORING_CLUSTER_INFO, 0x00000072: _ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_INFO, + 0x00000080: _BOOLEAN_SENSOR_CONFIGURATION_CLUSTER_INFO, + 0x00000081: _VALVE_CONFIGURATION_AND_CONTROL_CLUSTER_INFO, 0x00000096: _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO, 0x00000101: _DOOR_LOCK_CLUSTER_INFO, 0x00000102: _WINDOW_COVERING_CLUSTER_INFO, @@ -12738,6 +12945,8 @@ class ChipClusters: "RvcOperationalState": _RVC_OPERATIONAL_STATE_CLUSTER_INFO, "HepaFilterMonitoring": _HEPA_FILTER_MONITORING_CLUSTER_INFO, "ActivatedCarbonFilterMonitoring": _ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_INFO, + "BooleanSensorConfiguration": _BOOLEAN_SENSOR_CONFIGURATION_CLUSTER_INFO, + "ValveConfigurationAndControl": _VALVE_CONFIGURATION_AND_CONTROL_CLUSTER_INFO, "DemandResponseLoadControl": _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO, "DoorLock": _DOOR_LOCK_CLUSTER_INFO, "WindowCovering": _WINDOW_COVERING_CLUSTER_INFO, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index f3f396633491fa..ba97effddf0cff 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -20567,6 +20567,684 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = 0 +@dataclass +class BooleanSensorConfiguration(Cluster): + id: typing.ClassVar[int] = 0x00000080 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="sensitivityLevel", Tag=0x00000000, Type=typing.Optional[BooleanSensorConfiguration.Enums.SensitivityEnum]), + ClusterObjectFieldDescriptor(Label="alarmsActive", Tag=0x00000001, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="alarmsSuppressed", Tag=0x00000002, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="alarmsEnabled", Tag=0x00000003, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="eventList", Tag=0x0000FFFA, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="attributeList", Tag=0x0000FFFB, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="featureMap", Tag=0x0000FFFC, Type=uint), + ClusterObjectFieldDescriptor(Label="clusterRevision", Tag=0x0000FFFD, Type=uint), + ]) + + sensitivityLevel: 'typing.Optional[BooleanSensorConfiguration.Enums.SensitivityEnum]' = None + alarmsActive: 'typing.Optional[uint]' = None + alarmsSuppressed: 'typing.Optional[uint]' = None + alarmsEnabled: 'typing.Optional[uint]' = None + generatedCommandList: 'typing.List[uint]' = None + acceptedCommandList: 'typing.List[uint]' = None + eventList: 'typing.List[uint]' = None + attributeList: 'typing.List[uint]' = None + featureMap: 'uint' = None + clusterRevision: 'uint' = None + + class Enums: + class SensitivityEnum(MatterIntEnum): + kHigh = 0x00 + kStandard = 0x01 + kLow = 0x02 + # All received enum values that are not listed above will be mapped + # to kUnknownEnumValue. This is a helper enum value that should only + # be used by code to process how it handles receiving and unknown + # enum value. This specific should never be transmitted. + kUnknownEnumValue = 3, + + class Bitmaps: + class AlarmModeBitmap(IntFlag): + kVisual = 0x1 + kAudible = 0x2 + + class Feature(IntFlag): + kVisual = 0x1 + kAudible = 0x2 + kAlarmSuppress = 0x4 + kSensitivityLevel = 0x8 + + class Commands: + @dataclass + class SuppressRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000080 + command_id: typing.ClassVar[int] = 0x00000000 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="alarmsToSuppress", Tag=0, Type=uint), + ]) + + alarmsToSuppress: 'uint' = 0 + + class Attributes: + @dataclass + class SensitivityLevel(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[BooleanSensorConfiguration.Enums.SensitivityEnum]) + + value: 'typing.Optional[BooleanSensorConfiguration.Enums.SensitivityEnum]' = None + + @dataclass + class AlarmsActive(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[uint]) + + value: 'typing.Optional[uint]' = None + + @dataclass + class AlarmsSuppressed(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[uint]) + + value: 'typing.Optional[uint]' = None + + @dataclass + class AlarmsEnabled(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[uint]) + + value: 'typing.Optional[uint]' = None + + @dataclass + class GeneratedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF8 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AcceptedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF9 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class EventList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFA + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AttributeList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFB + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class FeatureMap(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFC + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class ClusterRevision(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFD + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + class Events: + @dataclass + class AlarmsStateChanged(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="alarmsActive", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="alarmsSuppressed", Tag=1, Type=typing.Optional[uint]), + ]) + + alarmsActive: 'uint' = 0 + alarmsSuppressed: 'typing.Optional[uint]' = None + + @dataclass + class SensorFault(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000080 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + + +@dataclass +class ValveConfigurationAndControl(Cluster): + id: typing.ClassVar[int] = 0x00000081 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="openDuration", Tag=0x00000000, Type=typing.Union[Nullable, uint]), + ClusterObjectFieldDescriptor(Label="autoCloseTime", Tag=0x00000001, Type=typing.Union[None, Nullable, uint]), + ClusterObjectFieldDescriptor(Label="remainingDuration", Tag=0x00000002, Type=typing.Union[None, Nullable, uint]), + ClusterObjectFieldDescriptor(Label="currentState", Tag=0x00000003, Type=typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]), + ClusterObjectFieldDescriptor(Label="targetState", Tag=0x00000004, Type=typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]), + ClusterObjectFieldDescriptor(Label="startUpState", Tag=0x00000005, Type=typing.Optional[ValveConfigurationAndControl.Enums.ValveStateEnum]), + ClusterObjectFieldDescriptor(Label="currentLevel", Tag=0x00000006, Type=typing.Union[None, Nullable, uint]), + ClusterObjectFieldDescriptor(Label="targetLevel", Tag=0x00000007, Type=typing.Union[None, Nullable, uint]), + ClusterObjectFieldDescriptor(Label="openLevel", Tag=0x00000008, Type=typing.Union[None, Nullable, uint]), + ClusterObjectFieldDescriptor(Label="valveFault", Tag=0x00000009, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="eventList", Tag=0x0000FFFA, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="attributeList", Tag=0x0000FFFB, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="featureMap", Tag=0x0000FFFC, Type=uint), + ClusterObjectFieldDescriptor(Label="clusterRevision", Tag=0x0000FFFD, Type=uint), + ]) + + openDuration: 'typing.Union[Nullable, uint]' = None + autoCloseTime: 'typing.Union[None, Nullable, uint]' = None + remainingDuration: 'typing.Union[None, Nullable, uint]' = None + currentState: 'typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]' = None + targetState: 'typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]' = None + startUpState: 'typing.Optional[ValveConfigurationAndControl.Enums.ValveStateEnum]' = None + currentLevel: 'typing.Union[None, Nullable, uint]' = None + targetLevel: 'typing.Union[None, Nullable, uint]' = None + openLevel: 'typing.Union[None, Nullable, uint]' = None + valveFault: 'typing.Optional[uint]' = None + generatedCommandList: 'typing.List[uint]' = None + acceptedCommandList: 'typing.List[uint]' = None + eventList: 'typing.List[uint]' = None + attributeList: 'typing.List[uint]' = None + featureMap: 'uint' = None + clusterRevision: 'uint' = None + + class Enums: + class ValveStateEnum(MatterIntEnum): + kOpen = 0x00 + kClosed = 0x01 + # All received enum values that are not listed above will be mapped + # to kUnknownEnumValue. This is a helper enum value that should only + # be used by code to process how it handles receiving and unknown + # enum value. This specific should never be transmitted. + kUnknownEnumValue = 2, + + class Bitmaps: + class Feature(IntFlag): + kTimeSync = 0x1 + kLevel = 0x2 + + class ValveFaultBitmap(IntFlag): + kGeneralFault = 0x1 + kBlocked = 0x2 + kLeaking = 0x4 + + class Commands: + @dataclass + class Open(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000081 + command_id: typing.ClassVar[int] = 0x00000000 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="openDuration", Tag=0, Type=typing.Optional[uint]), + ]) + + openDuration: 'typing.Optional[uint]' = None + + @dataclass + class Close(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000081 + command_id: typing.ClassVar[int] = 0x00000001 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ]) + + @dataclass + class SetLevel(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x00000081 + command_id: typing.ClassVar[int] = 0x00000002 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="level", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="openDuration", Tag=1, Type=typing.Optional[uint]), + ]) + + level: 'uint' = 0 + openDuration: 'typing.Optional[uint]' = None + + class Attributes: + @dataclass + class OpenDuration(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, uint]) + + value: 'typing.Union[Nullable, uint]' = NullValue + + @dataclass + class AutoCloseTime(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, uint]) + + value: 'typing.Union[None, Nullable, uint]' = None + + @dataclass + class RemainingDuration(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, uint]) + + value: 'typing.Union[None, Nullable, uint]' = None + + @dataclass + class CurrentState(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]) + + value: 'typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]' = NullValue + + @dataclass + class TargetState(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000004 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]) + + value: 'typing.Union[Nullable, ValveConfigurationAndControl.Enums.ValveStateEnum]' = NullValue + + @dataclass + class StartUpState(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000005 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[ValveConfigurationAndControl.Enums.ValveStateEnum]) + + value: 'typing.Optional[ValveConfigurationAndControl.Enums.ValveStateEnum]' = None + + @dataclass + class CurrentLevel(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000006 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, uint]) + + value: 'typing.Union[None, Nullable, uint]' = None + + @dataclass + class TargetLevel(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000007 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, uint]) + + value: 'typing.Union[None, Nullable, uint]' = None + + @dataclass + class OpenLevel(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000008 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Union[None, Nullable, uint]) + + value: 'typing.Union[None, Nullable, uint]' = None + + @dataclass + class ValveFault(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000009 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[uint]) + + value: 'typing.Optional[uint]' = None + + @dataclass + class GeneratedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF8 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AcceptedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF9 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class EventList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFA + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AttributeList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFB + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class FeatureMap(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFC + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class ClusterRevision(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFD + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + class Events: + @dataclass + class ValveStateChanged(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="valveState", Tag=0, Type=ValveConfigurationAndControl.Enums.ValveStateEnum), + ]) + + valveState: 'ValveConfigurationAndControl.Enums.ValveStateEnum' = 0 + + @dataclass + class ValveFault(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000081 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="valveFault", Tag=0, Type=uint), + ]) + + valveFault: 'uint' = 0 + + @dataclass class DemandResponseLoadControl(Cluster): id: typing.ClassVar[int] = 0x00000096 diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm index 949803a3e07a23..5aecd8f1128765 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm @@ -2696,6 +2696,102 @@ static BOOL AttributeIsSpecifiedInActivatedCarbonFilterMonitoringCluster(Attribu } } } +static BOOL AttributeIsSpecifiedInBooleanSensorConfigurationCluster(AttributeId aAttributeId) +{ + using namespace Clusters::BooleanSensorConfiguration; + switch (aAttributeId) { + case Attributes::SensitivityLevel::Id: { + return YES; + } + case Attributes::AlarmsActive::Id: { + return YES; + } + case Attributes::AlarmsSuppressed::Id: { + return YES; + } + case Attributes::AlarmsEnabled::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} +static BOOL AttributeIsSpecifiedInValveConfigurationAndControlCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ValveConfigurationAndControl; + switch (aAttributeId) { + case Attributes::OpenDuration::Id: { + return YES; + } + case Attributes::AutoCloseTime::Id: { + return YES; + } + case Attributes::RemainingDuration::Id: { + return YES; + } + case Attributes::CurrentState::Id: { + return YES; + } + case Attributes::TargetState::Id: { + return YES; + } + case Attributes::StartUpState::Id: { + return YES; + } + case Attributes::CurrentLevel::Id: { + return YES; + } + case Attributes::TargetLevel::Id: { + return YES; + } + case Attributes::OpenLevel::Id: { + return YES; + } + case Attributes::ValveFault::Id: { + return YES; + } + case Attributes::GeneratedCommandList::Id: { + return YES; + } + case Attributes::AcceptedCommandList::Id: { + return YES; + } + case Attributes::EventList::Id: { + return YES; + } + case Attributes::AttributeList::Id: { + return YES; + } + case Attributes::FeatureMap::Id: { + return YES; + } + case Attributes::ClusterRevision::Id: { + return YES; + } + default: { + return NO; + } + } +} static BOOL AttributeIsSpecifiedInDemandResponseLoadControlCluster(AttributeId aAttributeId) { using namespace Clusters::DemandResponseLoadControl; @@ -5835,6 +5931,12 @@ BOOL MTRAttributeIsSpecified(ClusterId aClusterId, AttributeId aAttributeId) case Clusters::ActivatedCarbonFilterMonitoring::Id: { return AttributeIsSpecifiedInActivatedCarbonFilterMonitoringCluster(aAttributeId); } + case Clusters::BooleanSensorConfiguration::Id: { + return AttributeIsSpecifiedInBooleanSensorConfigurationCluster(aAttributeId); + } + case Clusters::ValveConfigurationAndControl::Id: { + return AttributeIsSpecifiedInValveConfigurationAndControlCluster(aAttributeId); + } case Clusters::DemandResponseLoadControl::Id: { return AttributeIsSpecifiedInDemandResponseLoadControlCluster(aAttributeId); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm index 060a0c1de5d749..3405f126a26505 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm @@ -7020,6 +7020,216 @@ static id _Nullable DecodeAttributeValueForActivatedCarbonFilterMonitoringCluste *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; return nil; } +static id _Nullable DecodeAttributeValueForBooleanSensorConfigurationCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::BooleanSensorConfiguration; + switch (aAttributeId) { + case Attributes::SensitivityLevel::Id: { + using TypeInfo = Attributes::SensitivityLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue)]; + return value; + } + case Attributes::AlarmsActive::Id: { + using TypeInfo = Attributes::AlarmsActive::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:cppValue.Raw()]; + return value; + } + case Attributes::AlarmsSuppressed::Id: { + using TypeInfo = Attributes::AlarmsSuppressed::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:cppValue.Raw()]; + return value; + } + case Attributes::AlarmsEnabled::Id: { + using TypeInfo = Attributes::AlarmsEnabled::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:cppValue.Raw()]; + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + return nil; +} +static id _Nullable DecodeAttributeValueForValveConfigurationAndControlCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::ValveConfigurationAndControl; + switch (aAttributeId) { + case Attributes::OpenDuration::Id: { + using TypeInfo = Attributes::OpenDuration::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedInt:cppValue.Value()]; + } + return value; + } + case Attributes::AutoCloseTime::Id: { + using TypeInfo = Attributes::AutoCloseTime::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedLongLong:cppValue.Value()]; + } + return value; + } + case Attributes::RemainingDuration::Id: { + using TypeInfo = Attributes::RemainingDuration::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedInt:cppValue.Value()]; + } + return value; + } + case Attributes::CurrentState::Id: { + using TypeInfo = Attributes::CurrentState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.Value())]; + } + return value; + } + case Attributes::TargetState::Id: { + using TypeInfo = Attributes::TargetState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.Value())]; + } + return value; + } + case Attributes::StartUpState::Id: { + using TypeInfo = Attributes::StartUpState::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue)]; + return value; + } + case Attributes::CurrentLevel::Id: { + using TypeInfo = Attributes::CurrentLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedChar:cppValue.Value()]; + } + return value; + } + case Attributes::TargetLevel::Id: { + using TypeInfo = Attributes::TargetLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedChar:cppValue.Value()]; + } + return value; + } + case Attributes::OpenLevel::Id: { + using TypeInfo = Attributes::OpenLevel::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nullable value; + if (cppValue.IsNull()) { + value = nil; + } else { + value = [NSNumber numberWithUnsignedChar:cppValue.Value()]; + } + return value; + } + case Attributes::ValveFault::Id: { + using TypeInfo = Attributes::ValveFault::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedShort:cppValue.Raw()]; + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + return nil; +} static id _Nullable DecodeAttributeValueForDemandResponseLoadControlCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::DemandResponseLoadControl; @@ -16100,6 +16310,12 @@ id _Nullable MTRDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::T case Clusters::ActivatedCarbonFilterMonitoring::Id: { return DecodeAttributeValueForActivatedCarbonFilterMonitoringCluster(aPath.mAttributeId, aReader, aError); } + case Clusters::BooleanSensorConfiguration::Id: { + return DecodeAttributeValueForBooleanSensorConfigurationCluster(aPath.mAttributeId, aReader, aError); + } + case Clusters::ValveConfigurationAndControl::Id: { + return DecodeAttributeValueForValveConfigurationAndControlCluster(aPath.mAttributeId, aReader, aError); + } case Clusters::DemandResponseLoadControl::Id: { return DecodeAttributeValueForDemandResponseLoadControlCluster(aPath.mAttributeId, aReader, aError); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index c02edc106a7d0d..a2839c16e29d79 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -6669,6 +6669,250 @@ MTR_PROVISIONALLY_AVAILABLE @end +/** + * Cluster Boolean Sensor Configuration + * + * This cluster is used to configure a boolean sensor. + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBaseClusterBooleanSensorConfiguration : MTRGenericBaseCluster + +/** + * Command SuppressRequest + * + * This command is used to suppress the specified alarm. + */ +- (void)suppressRequestWithParams:(MTRBooleanSensorConfigurationClusterSuppressRequestParams *)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeSensitivityLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeSensitivityLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeSensitivityLevelWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeSensitivityLevelWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeSensitivityLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAlarmsActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAlarmsActiveWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAlarmsActiveWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAlarmsSuppressedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAlarmsSuppressedWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAlarmsSuppressedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAlarmsEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeAlarmsEnabledWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeAlarmsEnabledWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAlarmsEnabledWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAlarmsEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + +@interface MTRBaseClusterBooleanSensorConfiguration (Availability) + +/** + * For all instance methods (reads, writes, commands) that take a completion, + * the completion will be called on the provided queue. + */ +- (instancetype _Nullable)initWithDevice:(MTRBaseDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + +/** + * Cluster Valve Configuration and Control + * + * This cluster is used to configure a valve. + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBaseClusterValveConfigurationAndControl : MTRGenericBaseCluster + +/** + * Command Open + * + * This command is used to set the valve to its fully open position. + */ +- (void)openWithParams:(MTRValveConfigurationAndControlClusterOpenParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +/** + * Command Close + * + * This command is used to set the valve to its fully closed position. + */ +- (void)closeWithParams:(MTRValveConfigurationAndControlClusterCloseParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)closeWithCompletion:(MTRStatusCompletion)completion + MTR_PROVISIONALLY_AVAILABLE; +/** + * Command SetLevel + * + * This command is used to set the valve to a specific level. + */ +- (void)setLevelWithParams:(MTRValveConfigurationAndControlClusterSetLevelParams *)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeOpenDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenDurationWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenDurationWithValue:(NSNumber * _Nullable)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeOpenDurationWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeOpenDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAutoCloseTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAutoCloseTimeWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAutoCloseTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeRemainingDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeRemainingDurationWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeRemainingDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeCurrentStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeTargetStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeTargetStateWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeTargetStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeStartUpStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeStartUpStateWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeStartUpStateWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeStartUpStateWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeStartUpStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeTargetLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeTargetLevelWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeTargetLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeOpenLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenLevelWithValue:(NSNumber * _Nullable)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeOpenLevelWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeOpenLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeValveFaultWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeValveFaultWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeValveFaultWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + +@interface MTRBaseClusterValveConfigurationAndControl (Availability) + +/** + * For all instance methods (reads, writes, commands) that take a completion, + * the completion will be called on the provided queue. + */ +- (instancetype _Nullable)initWithDevice:(MTRBaseDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + /** * Cluster Demand Response Load Control * @@ -15408,6 +15652,40 @@ typedef NS_OPTIONS(uint32_t, MTRActivatedCarbonFilterMonitoringFeature) { MTRActivatedCarbonFilterMonitoringFeatureReplacementProductList MTR_PROVISIONALLY_AVAILABLE = 0x4, } MTR_PROVISIONALLY_AVAILABLE; +typedef NS_ENUM(uint8_t, MTRBooleanSensorConfigurationSensitivity) { + MTRBooleanSensorConfigurationSensitivityHigh MTR_PROVISIONALLY_AVAILABLE = 0x00, + MTRBooleanSensorConfigurationSensitivityStandard MTR_PROVISIONALLY_AVAILABLE = 0x01, + MTRBooleanSensorConfigurationSensitivityLow MTR_PROVISIONALLY_AVAILABLE = 0x02, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_OPTIONS(uint8_t, MTRBooleanSensorConfigurationAlarmModeBitmap) { + MTRBooleanSensorConfigurationAlarmModeBitmapVisual MTR_PROVISIONALLY_AVAILABLE = 0x1, + MTRBooleanSensorConfigurationAlarmModeBitmapAudible MTR_PROVISIONALLY_AVAILABLE = 0x2, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_OPTIONS(uint32_t, MTRBooleanSensorConfigurationFeature) { + MTRBooleanSensorConfigurationFeatureVisual MTR_PROVISIONALLY_AVAILABLE = 0x1, + MTRBooleanSensorConfigurationFeatureAudible MTR_PROVISIONALLY_AVAILABLE = 0x2, + MTRBooleanSensorConfigurationFeatureAlarmSuppress MTR_PROVISIONALLY_AVAILABLE = 0x4, + MTRBooleanSensorConfigurationFeatureSensitivityLevel MTR_PROVISIONALLY_AVAILABLE = 0x8, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_ENUM(uint8_t, MTRValveConfigurationAndControlValveState) { + MTRValveConfigurationAndControlValveStateOpen MTR_PROVISIONALLY_AVAILABLE = 0x00, + MTRValveConfigurationAndControlValveStateClosed MTR_PROVISIONALLY_AVAILABLE = 0x01, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_OPTIONS(uint32_t, MTRValveConfigurationAndControlFeature) { + MTRValveConfigurationAndControlFeatureTimeSync MTR_PROVISIONALLY_AVAILABLE = 0x1, + MTRValveConfigurationAndControlFeatureLevel MTR_PROVISIONALLY_AVAILABLE = 0x2, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_OPTIONS(uint16_t, MTRValveConfigurationAndControlValveFaultBitmap) { + MTRValveConfigurationAndControlValveFaultBitmapGeneralFault MTR_PROVISIONALLY_AVAILABLE = 0x1, + MTRValveConfigurationAndControlValveFaultBitmapBlocked MTR_PROVISIONALLY_AVAILABLE = 0x2, + MTRValveConfigurationAndControlValveFaultBitmapLeaking MTR_PROVISIONALLY_AVAILABLE = 0x4, +} MTR_PROVISIONALLY_AVAILABLE; + typedef NS_ENUM(uint8_t, MTRDemandResponseLoadControlCriticalityLevel) { MTRDemandResponseLoadControlCriticalityLevelUnknown MTR_PROVISIONALLY_AVAILABLE = 0x00, MTRDemandResponseLoadControlCriticalityLevelGreen MTR_PROVISIONALLY_AVAILABLE = 0x01, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm index affa6d51ceedd2..373be629c1134c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm @@ -47681,6 +47681,1202 @@ + (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheC @end +@implementation MTRBaseClusterBooleanSensorConfiguration + +- (void)suppressRequestWithParams:(MTRBooleanSensorConfigurationClusterSuppressRequestParams *)params completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRBooleanSensorConfigurationClusterSuppressRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = BooleanSensorConfiguration::Commands::SuppressRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)readAttributeSensitivityLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::SensitivityLevel::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeSensitivityLevelWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeSensitivityLevelWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; +} +- (void)writeAttributeSensitivityLevelWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + value = [value copy]; + + auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + chip::Optional timedWriteTimeout; + if (params != nil) { + if (params.timedWriteTimeout != nil){ + timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue); + } + } + + ListFreer listFreer; + using TypeInfo = BooleanSensorConfiguration::Attributes::SensitivityLevel::TypeInfo; + TypeInfo::Type cppValue; + cppValue = static_cast>(value.unsignedCharValue); + + chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint); + return cppCluster.WriteAttribute(cppValue, bridge, successCb, failureCb, timedWriteTimeout); }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)subscribeAttributeSensitivityLevelWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::SensitivityLevel::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeSensitivityLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::SensitivityLevel::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAlarmsActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsActive::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAlarmsActiveWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsActive::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAlarmsActiveWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsActive::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAlarmsSuppressedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsSuppressed::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAlarmsSuppressedWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsSuppressed::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAlarmsSuppressedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsSuppressed::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAlarmsEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsEnabled::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeAlarmsEnabledWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeAlarmsEnabledWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; +} +- (void)writeAttributeAlarmsEnabledWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + value = [value copy]; + + auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + chip::Optional timedWriteTimeout; + if (params != nil) { + if (params.timedWriteTimeout != nil){ + timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue); + } + } + + ListFreer listFreer; + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsEnabled::TypeInfo; + TypeInfo::Type cppValue; + cppValue = static_cast>(value.unsignedCharValue); + + chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint); + return cppCluster.WriteAttribute(cppValue, bridge, successCb, failureCb, timedWriteTimeout); }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)subscribeAttributeAlarmsEnabledWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsEnabled::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAlarmsEnabledWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AlarmsEnabled::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::GeneratedCommandList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::GeneratedCommandList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::GeneratedCommandList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AcceptedCommandList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AcceptedCommandList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AcceptedCommandList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::EventList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::EventList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::EventList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AttributeList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AttributeList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::AttributeList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::FeatureMap::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::FeatureMap::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::FeatureMap::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::ClusterRevision::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::ClusterRevision::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = BooleanSensorConfiguration::Attributes::ClusterRevision::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +@end + +@implementation MTRBaseClusterValveConfigurationAndControl + +- (void)openWithParams:(MTRValveConfigurationAndControlClusterOpenParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRValveConfigurationAndControlClusterOpenParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ValveConfigurationAndControl::Commands::Open::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} +- (void)closeWithCompletion:(MTRStatusCompletion)completion +{ + [self closeWithParams:nil completion:completion]; +} +- (void)closeWithParams:(MTRValveConfigurationAndControlClusterCloseParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRValveConfigurationAndControlClusterCloseParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ValveConfigurationAndControl::Commands::Close::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} +- (void)setLevelWithParams:(MTRValveConfigurationAndControlClusterSetLevelParams *)params completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRValveConfigurationAndControlClusterSetLevelParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ValveConfigurationAndControl::Commands::SetLevel::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)readAttributeOpenDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeOpenDurationWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeOpenDurationWithValue:(NSNumber * _Nullable) value params:nil completion:completion]; +} +- (void)writeAttributeOpenDurationWithValue:(NSNumber * _Nullable)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + value = [value copy]; + + auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + chip::Optional timedWriteTimeout; + if (params != nil) { + if (params.timedWriteTimeout != nil){ + timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue); + } + } + + ListFreer listFreer; + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedIntValue; + } + + chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint); + return cppCluster.WriteAttribute(cppValue, bridge, successCb, failureCb, timedWriteTimeout); }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)subscribeAttributeOpenDurationWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeOpenDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenDuration::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAutoCloseTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AutoCloseTime::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAutoCloseTimeWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AutoCloseTime::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAutoCloseTimeWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AutoCloseTime::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeRemainingDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::RemainingDuration::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeRemainingDurationWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::RemainingDuration::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeRemainingDurationWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::RemainingDuration::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentState::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeCurrentStateWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentState::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeCurrentStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentState::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeTargetStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::TargetState::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeTargetStateWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::TargetState::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeTargetStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::TargetState::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeStartUpStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::StartUpState::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeStartUpStateWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeStartUpStateWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; +} +- (void)writeAttributeStartUpStateWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + value = [value copy]; + + auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + chip::Optional timedWriteTimeout; + if (params != nil) { + if (params.timedWriteTimeout != nil){ + timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue); + } + } + + ListFreer listFreer; + using TypeInfo = ValveConfigurationAndControl::Attributes::StartUpState::TypeInfo; + TypeInfo::Type cppValue; + cppValue = static_cast>(value.unsignedCharValue); + + chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint); + return cppCluster.WriteAttribute(cppValue, bridge, successCb, failureCb, timedWriteTimeout); }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)subscribeAttributeStartUpStateWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::StartUpState::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeStartUpStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::StartUpState::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentLevel::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeCurrentLevelWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentLevel::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeCurrentLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::CurrentLevel::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeTargetLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::TargetLevel::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeTargetLevelWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::TargetLevel::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeTargetLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::TargetLevel::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeOpenLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenLevel::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeOpenLevelWithValue:(NSNumber * _Nullable)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeOpenLevelWithValue:(NSNumber * _Nullable) value params:nil completion:completion]; +} +- (void)writeAttributeOpenLevelWithValue:(NSNumber * _Nullable)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + value = [value copy]; + + auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + chip::Optional timedWriteTimeout; + if (params != nil) { + if (params.timedWriteTimeout != nil){ + timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue); + } + } + + ListFreer listFreer; + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenLevel::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.unsignedCharValue; + } + + chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint); + return cppCluster.WriteAttribute(cppValue, bridge, successCb, failureCb, timedWriteTimeout); }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)subscribeAttributeOpenLevelWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenLevel::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeOpenLevelWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::OpenLevel::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeValveFaultWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::ValveFault::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeValveFaultWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::ValveFault::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeValveFaultWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::ValveFault::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::EventList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::EventList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::EventList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AttributeList::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AttributeList::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::AttributeList::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::FeatureMap::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::FeatureMap::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::FeatureMap::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::ClusterRevision::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::ClusterRevision::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = ValveConfigurationAndControl::Attributes::ClusterRevision::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +@end + @implementation MTRBaseClusterDemandResponseLoadControl - (void)registerLoadControlProgramRequestWithParams:(MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams *)params completion:(MTRStatusCompletion)completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 6a10bcbf73ca5e..6ae2a1097e82d6 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -145,6 +145,8 @@ typedef NS_ENUM(uint32_t, MTRClusterIDType) { MTRClusterIDTypeRVCOperationalStateID MTR_PROVISIONALLY_AVAILABLE = 0x00000061, MTRClusterIDTypeHEPAFilterMonitoringID MTR_PROVISIONALLY_AVAILABLE = 0x00000071, MTRClusterIDTypeActivatedCarbonFilterMonitoringID MTR_PROVISIONALLY_AVAILABLE = 0x00000072, + MTRClusterIDTypeBooleanSensorConfigurationID MTR_PROVISIONALLY_AVAILABLE = 0x00000080, + MTRClusterIDTypeValveConfigurationAndControlID MTR_PROVISIONALLY_AVAILABLE = 0x00000081, MTRClusterIDTypeDemandResponseLoadControlID MTR_PROVISIONALLY_AVAILABLE = 0x00000096, MTRClusterIDTypeDoorLockID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000101, MTRClusterIDTypeWindowCoveringID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000102, @@ -2528,6 +2530,36 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterActivatedCarbonFilterMonitoringAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, MTRAttributeIDTypeClusterActivatedCarbonFilterMonitoringAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster BooleanSensorConfiguration attributes + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeSensitivityLevelID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsActiveID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsSuppressedID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsEnabledID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeEventListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeEventListID, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, + MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + + // Cluster ValveConfigurationAndControl attributes + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeOpenDurationID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeAutoCloseTimeID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeRemainingDurationID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeCurrentStateID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeTargetStateID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeStartUpStateID MTR_PROVISIONALLY_AVAILABLE = 0x00000005, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeCurrentLevelID MTR_PROVISIONALLY_AVAILABLE = 0x00000006, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeTargetLevelID MTR_PROVISIONALLY_AVAILABLE = 0x00000007, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeOpenLevelID MTR_PROVISIONALLY_AVAILABLE = 0x00000008, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeValveFaultID MTR_PROVISIONALLY_AVAILABLE = 0x00000009, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeEventListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeEventListID, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, + MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster DemandResponseLoadControl attributes MTRAttributeIDTypeClusterDemandResponseLoadControlAttributeDeviceClassID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, MTRAttributeIDTypeClusterDemandResponseLoadControlAttributeLoadControlProgramsID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, @@ -6068,6 +6100,14 @@ typedef NS_ENUM(uint32_t, MTRCommandIDType) { // Cluster ActivatedCarbonFilterMonitoring commands MTRCommandIDTypeClusterActivatedCarbonFilterMonitoringCommandResetConditionID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + // Cluster BooleanSensorConfiguration commands + MTRCommandIDTypeClusterBooleanSensorConfigurationCommandSuppressRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + + // Cluster ValveConfigurationAndControl commands + MTRCommandIDTypeClusterValveConfigurationAndControlCommandOpenID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTRCommandIDTypeClusterValveConfigurationAndControlCommandCloseID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTRCommandIDTypeClusterValveConfigurationAndControlCommandSetLevelID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + // Cluster DemandResponseLoadControl commands MTRCommandIDTypeClusterDemandResponseLoadControlCommandRegisterLoadControlProgramRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, MTRCommandIDTypeClusterDemandResponseLoadControlCommandUnregisterLoadControlProgramRequestID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, @@ -6911,6 +6951,14 @@ typedef NS_ENUM(uint32_t, MTREventIDType) { MTREventIDTypeClusterRVCOperationalStateEventOperationalErrorID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, MTREventIDTypeClusterRVCOperationalStateEventOperationCompletionID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + // Cluster BooleanSensorConfiguration events + MTREventIDTypeClusterBooleanSensorConfigurationEventAlarmsStateChangedID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTREventIDTypeClusterBooleanSensorConfigurationEventSensorFaultID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + + // Cluster ValveConfigurationAndControl events + MTREventIDTypeClusterValveConfigurationAndControlEventValveStateChangedID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTREventIDTypeClusterValveConfigurationAndControlEventValveFaultID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + // Cluster DemandResponseLoadControl events MTREventIDTypeClusterDemandResponseLoadControlEventLoadControlEventStatusChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h index 574dab0174b722..d092e41717ff73 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h @@ -3152,6 +3152,124 @@ MTR_PROVISIONALLY_AVAILABLE @end +/** + * Cluster Boolean Sensor Configuration + * This cluster is used to configure a boolean sensor. + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRClusterBooleanSensorConfiguration : MTRGenericCluster + +- (void)suppressRequestWithParams:(MTRBooleanSensorConfigurationClusterSuppressRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeSensitivityLevelWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeSensitivityLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeSensitivityLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAlarmsActiveWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAlarmsSuppressedWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAlarmsEnabledWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeAlarmsEnabledWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeAlarmsEnabledWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + +@interface MTRClusterBooleanSensorConfiguration (Availability) + +/** + * For all instance methods that take a completion (i.e. command invocations), + * the completion will be called on the provided queue. + */ +- (instancetype _Nullable)initWithDevice:(MTRDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + +/** + * Cluster Valve Configuration and Control + * This cluster is used to configure a valve. + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRClusterValveConfigurationAndControl : MTRGenericCluster + +- (void)openWithParams:(MTRValveConfigurationAndControlClusterOpenParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)closeWithParams:(MTRValveConfigurationAndControlClusterCloseParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)closeWithExpectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion + MTR_PROVISIONALLY_AVAILABLE; +- (void)setLevelWithParams:(MTRValveConfigurationAndControlClusterSetLevelParams *)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeOpenDurationWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenDurationWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenDurationWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAutoCloseTimeWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeRemainingDurationWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeCurrentStateWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeTargetStateWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeStartUpStateWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeStartUpStateWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeStartUpStateWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeCurrentLevelWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeTargetLevelWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeOpenLevelWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeOpenLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeValveFaultWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + +@interface MTRClusterValveConfigurationAndControl (Availability) + +/** + * For all instance methods that take a completion (i.e. command invocations), + * the completion will be called on the provided queue. + */ +- (instancetype _Nullable)initWithDevice:(MTRDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + /** * Cluster Demand Response Load Control * This cluster provides an interface to the functionality of Smart Energy Demand Response and Load Control. diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm index afb24197208ed2..6fb97ebb52e720 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm @@ -8592,6 +8592,311 @@ - (void)writeAttributeLastChangedTimeWithValue:(NSDictionary *)d @end +@implementation MTRClusterBooleanSensorConfiguration + +- (void)suppressRequestWithParams:(MTRBooleanSensorConfigurationClusterSuppressRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRBooleanSensorConfigurationClusterSuppressRequestParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = BooleanSensorConfiguration::Commands::SuppressRequest::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (NSDictionary * _Nullable)readAttributeSensitivityLevelWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeSensitivityLevelID) params:params]; +} + +- (void)writeAttributeSensitivityLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeSensitivityLevelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeSensitivityLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeSensitivityLevelID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeAlarmsActiveWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsActiveID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAlarmsSuppressedWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsSuppressedID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAlarmsEnabledWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsEnabledID) params:params]; +} + +- (void)writeAttributeAlarmsEnabledWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeAlarmsEnabledWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeAlarmsEnabledWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAlarmsEnabledID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeGeneratedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAcceptedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeEventListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeAttributeListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeFeatureMapID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeBooleanSensorConfigurationID) attributeID:@(MTRAttributeIDTypeClusterBooleanSensorConfigurationAttributeClusterRevisionID) params:params]; +} + +@end + +@implementation MTRClusterValveConfigurationAndControl + +- (void)openWithParams:(MTRValveConfigurationAndControlClusterOpenParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRValveConfigurationAndControlClusterOpenParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ValveConfigurationAndControl::Commands::Open::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)closeWithExpectedValues:(NSArray *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + [self closeWithParams:nil expectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs completion:completion]; +} +- (void)closeWithParams:(MTRValveConfigurationAndControlClusterCloseParams * _Nullable)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRValveConfigurationAndControlClusterCloseParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ValveConfigurationAndControl::Commands::Close::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (void)setLevelWithParams:(MTRValveConfigurationAndControlClusterSetLevelParams *)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion +{ + if (params == nil) { + params = [[MTRValveConfigurationAndControlClusterSetLevelParams + alloc] init]; + } + + auto responseHandler = ^(id _Nullable response, NSError * _Nullable error) { + completion(error); + }; + + auto * timedInvokeTimeoutMs = params.timedInvokeTimeoutMs; + + using RequestType = ValveConfigurationAndControl::Commands::SetLevel::Type; + [self.device _invokeKnownCommandWithEndpointID:@(self.endpoint) + clusterID:@(RequestType::GetClusterId()) + commandID:@(RequestType::GetCommandId()) + commandPayload:params + expectedValues:expectedValues + expectedValueInterval:expectedValueIntervalMs + timedInvokeTimeout:timedInvokeTimeoutMs + serverSideProcessingTimeout:params.serverSideProcessingTimeout + responseClass:nil + queue:self.callbackQueue + completion:responseHandler]; +} + +- (NSDictionary * _Nullable)readAttributeOpenDurationWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeOpenDurationID) params:params]; +} + +- (void)writeAttributeOpenDurationWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeOpenDurationWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeOpenDurationWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeOpenDurationID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeAutoCloseTimeWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeAutoCloseTimeID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeRemainingDurationWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeRemainingDurationID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeCurrentStateWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeCurrentStateID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeTargetStateWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeTargetStateID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeStartUpStateWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeStartUpStateID) params:params]; +} + +- (void)writeAttributeStartUpStateWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeStartUpStateWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeStartUpStateWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeStartUpStateID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeCurrentLevelWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeCurrentLevelID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeTargetLevelWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeTargetLevelID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeOpenLevelWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeOpenLevelID) params:params]; +} + +- (void)writeAttributeOpenLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeOpenLevelWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeOpenLevelWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeOpenLevelID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeValveFaultWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeValveFaultID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeGeneratedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeAcceptedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeEventListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeAttributeListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeFeatureMapID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeValveConfigurationAndControlID) attributeID:@(MTRAttributeIDTypeClusterValveConfigurationAndControlAttributeClusterRevisionID) params:params]; +} + +@end + @implementation MTRClusterDemandResponseLoadControl - (void)registerLoadControlProgramRequestWithParams:(MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams *)params expectedValues:(NSArray *> * _Nullable)expectedValues expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h index 4a697b150ee6d1..4eb0b36106f127 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h @@ -5394,6 +5394,126 @@ MTR_PROVISIONALLY_AVAILABLE @property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBooleanSensorConfigurationClusterSuppressRequestParams : NSObject + +@property (nonatomic, copy) NSNumber * _Nonnull alarmsToSuppress MTR_PROVISIONALLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRValveConfigurationAndControlClusterOpenParams : NSObject + +@property (nonatomic, copy) NSNumber * _Nullable openDuration MTR_PROVISIONALLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRValveConfigurationAndControlClusterCloseParams : NSObject +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRValveConfigurationAndControlClusterSetLevelParams : NSObject + +@property (nonatomic, copy) NSNumber * _Nonnull level MTR_PROVISIONALLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nullable openDuration MTR_PROVISIONALLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + MTR_PROVISIONALLY_AVAILABLE @interface MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams : NSObject diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm index 2bda728e8cd493..f9d6db9f8b21a0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm @@ -14741,6 +14741,328 @@ - (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader } @end +@implementation MTRBooleanSensorConfigurationClusterSuppressRequestParams +- (instancetype)init +{ + if (self = [super init]) { + + _alarmsToSuppress = @(0); + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRBooleanSensorConfigurationClusterSuppressRequestParams alloc] init]; + + other.alarmsToSuppress = self.alarmsToSuppress; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: alarmsToSuppress:%@; >", NSStringFromClass([self class]), _alarmsToSuppress]; + return descriptionString; +} + +@end + +@implementation MTRBooleanSensorConfigurationClusterSuppressRequestParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::Type encodableStruct; + ListFreer listFreer; + { + encodableStruct.alarmsToSuppress = static_cast>(self.alarmsToSuppress.unsignedCharValue); + } + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRValveConfigurationAndControlClusterOpenParams +- (instancetype)init +{ + if (self = [super init]) { + + _openDuration = nil; + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRValveConfigurationAndControlClusterOpenParams alloc] init]; + + other.openDuration = self.openDuration; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: openDuration:%@; >", NSStringFromClass([self class]), _openDuration]; + return descriptionString; +} + +@end + +@implementation MTRValveConfigurationAndControlClusterOpenParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Type encodableStruct; + ListFreer listFreer; + { + if (self.openDuration != nil) { + auto & definedValue_0 = encodableStruct.openDuration.Emplace(); + definedValue_0 = self.openDuration.unsignedIntValue; + } + } + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRValveConfigurationAndControlClusterCloseParams +- (instancetype)init +{ + if (self = [super init]) { + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRValveConfigurationAndControlClusterCloseParams alloc] init]; + + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: >", NSStringFromClass([self class])]; + return descriptionString; +} + +@end + +@implementation MTRValveConfigurationAndControlClusterCloseParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Type encodableStruct; + ListFreer listFreer; + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + +@implementation MTRValveConfigurationAndControlClusterSetLevelParams +- (instancetype)init +{ + if (self = [super init]) { + + _level = @(0); + + _openDuration = nil; + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRValveConfigurationAndControlClusterSetLevelParams alloc] init]; + + other.level = self.level; + other.openDuration = self.openDuration; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: level:%@; openDuration:%@; >", NSStringFromClass([self class]), _level, _openDuration]; + return descriptionString; +} + +@end + +@implementation MTRValveConfigurationAndControlClusterSetLevelParams (InternalMethods) + +- (CHIP_ERROR)_encodeToTLVReader:(chip::System::PacketBufferTLVReader &)reader +{ + chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::Type encodableStruct; + ListFreer listFreer; + { + encodableStruct.level = self.level.unsignedCharValue; + } + { + if (self.openDuration != nil) { + auto & definedValue_0 = encodableStruct.openDuration.Emplace(); + definedValue_0 = self.openDuration.unsignedIntValue; + } + } + + auto buffer = chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSizeWithoutReserve, 0); + if (buffer.IsNull()) { + return CHIP_ERROR_NO_MEMORY; + } + + chip::System::PacketBufferTLVWriter writer; + // Commands never need chained buffers, since they cannot be chunked. + writer.Init(std::move(buffer), /* useChainedBuffers = */ false); + + ReturnErrorOnFailure(chip::app::DataModel::Encode(writer, chip::TLV::AnonymousTag(), encodableStruct)); + + ReturnErrorOnFailure(writer.Finalize(&buffer)); + + reader.Init(std::move(buffer)); + return reader.Next(chip::TLV::kTLVType_Structure, chip::TLV::AnonymousTag()); +} + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error +{ + chip::System::PacketBufferTLVReader reader; + CHIP_ERROR err = [self _encodeToTLVReader:reader]; + if (err != CHIP_NO_ERROR) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:err]; + } + return nil; + } + + auto decodedObj = MTRDecodeDataValueDictionaryFromCHIPTLV(&reader); + if (decodedObj == nil) { + if (error) { + *error = [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]; + } + } + return decodedObj; +} +@end + @implementation MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams - (instancetype)init { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h index 720131619d587b..6b1e319e0f69c4 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloads_Internal.h @@ -946,6 +946,30 @@ NS_ASSUME_NONNULL_BEGIN @end +@interface MTRBooleanSensorConfigurationClusterSuppressRequestParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRValveConfigurationAndControlClusterOpenParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRValveConfigurationAndControlClusterCloseParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + +@interface MTRValveConfigurationAndControlClusterSetLevelParams (InternalMethods) + +- (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; + +@end + @interface MTRDemandResponseLoadControlClusterRegisterLoadControlProgramRequestParams (InternalMethods) - (NSDictionary * _Nullable)_encodeAsDataValue:(NSError * __autoreleasing *)error; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm index 68e801089297d2..205425ea1ed5c0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm @@ -545,6 +545,24 @@ static BOOL CommandNeedsTimedInvokeInActivatedCarbonFilterMonitoringCluster(Attr } } } +static BOOL CommandNeedsTimedInvokeInBooleanSensorConfigurationCluster(AttributeId aAttributeId) +{ + using namespace Clusters::BooleanSensorConfiguration; + switch (aAttributeId) { + default: { + return NO; + } + } +} +static BOOL CommandNeedsTimedInvokeInValveConfigurationAndControlCluster(AttributeId aAttributeId) +{ + using namespace Clusters::ValveConfigurationAndControl; + switch (aAttributeId) { + default: { + return NO; + } + } +} static BOOL CommandNeedsTimedInvokeInDemandResponseLoadControlCluster(AttributeId aAttributeId) { using namespace Clusters::DemandResponseLoadControl; @@ -1128,6 +1146,12 @@ BOOL MTRCommandNeedsTimedInvoke(NSNumber * _Nonnull aClusterID, NSNumber * _Nonn case Clusters::ActivatedCarbonFilterMonitoring::Id: { return CommandNeedsTimedInvokeInActivatedCarbonFilterMonitoringCluster(commandID); } + case Clusters::BooleanSensorConfiguration::Id: { + return CommandNeedsTimedInvokeInBooleanSensorConfigurationCluster(commandID); + } + case Clusters::ValveConfigurationAndControl::Id: { + return CommandNeedsTimedInvokeInValveConfigurationAndControlCluster(commandID); + } case Clusters::DemandResponseLoadControl::Id: { return CommandNeedsTimedInvokeInDemandResponseLoadControlCluster(commandID); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm b/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm index 1fe61e9f7b8839..43f045900f6aaf 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRDeviceTypeMetadata.mm @@ -54,6 +54,9 @@ { 0x0000002B, DeviceTypeClass::Simple, "Matter Fan" }, { 0x0000002C, DeviceTypeClass::Simple, "Matter Air Quality Sensor" }, { 0x0000002D, DeviceTypeClass::Simple, "Matter Air Purifier" }, + { 0x00000041, DeviceTypeClass::Simple, "Matter Boolean Sensor" }, + { 0x00000042, DeviceTypeClass::Simple, "Matter Valve" }, + { 0x00000043, DeviceTypeClass::Simple, "Matter Water Leak Detector" }, { 0x00000070, DeviceTypeClass::Simple, "Matter Refrigerator" }, { 0x00000071, DeviceTypeClass::Simple, "Matter Temperature Controlled Cabinet" }, { 0x00000072, DeviceTypeClass::Simple, "Matter Room Air Conditioner" }, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index a7e313fec476a2..9fe8aeb9e6fceb 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -2249,6 +2249,101 @@ static id _Nullable DecodeEventPayloadForActivatedCarbonFilterMonitoringCluster( *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; return nil; } +static id _Nullable DecodeEventPayloadForBooleanSensorConfigurationCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::BooleanSensorConfiguration; + switch (aEventId) { + case Events::AlarmsStateChanged::Id: { + Events::AlarmsStateChanged::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRBooleanSensorConfigurationClusterAlarmsStateChangedEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.alarmsActive.Raw()]; + value.alarmsActive = memberValue; + } while (0); + do { + NSNumber * _Nullable memberValue; + if (cppValue.alarmsSuppressed.HasValue()) { + memberValue = [NSNumber numberWithUnsignedChar:cppValue.alarmsSuppressed.Value().Raw()]; + } else { + memberValue = nil; + } + value.alarmsSuppressed = memberValue; + } while (0); + + return value; + } + case Events::SensorFault::Id: { + Events::SensorFault::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRBooleanSensorConfigurationClusterSensorFaultEvent new]; + + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + return nil; +} +static id _Nullable DecodeEventPayloadForValveConfigurationAndControlCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::ValveConfigurationAndControl; + switch (aEventId) { + case Events::ValveStateChanged::Id: { + Events::ValveStateChanged::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRValveConfigurationAndControlClusterValveStateChangedEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.valveState)]; + value.valveState = memberValue; + } while (0); + + return value; + } + case Events::ValveFault::Id: { + Events::ValveFault::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRValveConfigurationAndControlClusterValveFaultEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedShort:cppValue.valveFault.Raw()]; + value.valveFault = memberValue; + } while (0); + + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + return nil; +} static id _Nullable DecodeEventPayloadForDemandResponseLoadControlCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::DemandResponseLoadControl; @@ -3624,6 +3719,12 @@ id _Nullable MTRDecodeEventPayload(const ConcreteEventPath & aPath, TLV::TLVRead case Clusters::ActivatedCarbonFilterMonitoring::Id: { return DecodeEventPayloadForActivatedCarbonFilterMonitoringCluster(aPath.mEventId, aReader, aError); } + case Clusters::BooleanSensorConfiguration::Id: { + return DecodeEventPayloadForBooleanSensorConfigurationCluster(aPath.mEventId, aReader, aError); + } + case Clusters::ValveConfigurationAndControl::Id: { + return DecodeEventPayloadForValveConfigurationAndControlCluster(aPath.mEventId, aReader, aError); + } case Clusters::DemandResponseLoadControl::Id: { return DecodeEventPayloadForDemandResponseLoadControlCluster(aPath.mEventId, aReader, aError); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index 9533374a866d00..4d58ccb5d27b3f 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1004,6 +1004,26 @@ MTR_PROVISIONALLY_AVAILABLE @property (nonatomic, copy) NSString * _Nonnull productIdentifierValue MTR_PROVISIONALLY_AVAILABLE; @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBooleanSensorConfigurationClusterAlarmsStateChangedEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull alarmsActive MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nullable alarmsSuppressed MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBooleanSensorConfigurationClusterSensorFaultEvent : NSObject +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRValveConfigurationAndControlClusterValveStateChangedEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull valveState MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRValveConfigurationAndControlClusterValveFaultEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull valveFault MTR_PROVISIONALLY_AVAILABLE; +@end + MTR_PROVISIONALLY_AVAILABLE @interface MTRDemandResponseLoadControlClusterHeatingSourceControlStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull heatingSource MTR_PROVISIONALLY_AVAILABLE; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index 46dcf3cef0b058..251d0f89b5aeeb 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -3975,6 +3975,113 @@ - (NSString *)description @end +@implementation MTRBooleanSensorConfigurationClusterAlarmsStateChangedEvent +- (instancetype)init +{ + if (self = [super init]) { + + _alarmsActive = @(0); + + _alarmsSuppressed = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRBooleanSensorConfigurationClusterAlarmsStateChangedEvent alloc] init]; + + other.alarmsActive = self.alarmsActive; + other.alarmsSuppressed = self.alarmsSuppressed; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: alarmsActive:%@; alarmsSuppressed:%@; >", NSStringFromClass([self class]), _alarmsActive, _alarmsSuppressed]; + return descriptionString; +} + +@end + +@implementation MTRBooleanSensorConfigurationClusterSensorFaultEvent +- (instancetype)init +{ + if (self = [super init]) { + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRBooleanSensorConfigurationClusterSensorFaultEvent alloc] init]; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: >", NSStringFromClass([self class])]; + return descriptionString; +} + +@end + +@implementation MTRValveConfigurationAndControlClusterValveStateChangedEvent +- (instancetype)init +{ + if (self = [super init]) { + + _valveState = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRValveConfigurationAndControlClusterValveStateChangedEvent alloc] init]; + + other.valveState = self.valveState; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: valveState:%@; >", NSStringFromClass([self class]), _valveState]; + return descriptionString; +} + +@end + +@implementation MTRValveConfigurationAndControlClusterValveFaultEvent +- (instancetype)init +{ + if (self = [super init]) { + + _valveFault = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRValveConfigurationAndControlClusterValveFaultEvent alloc] init]; + + other.valveFault = self.valveFault; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: valveFault:%@; >", NSStringFromClass([self class]), _valveFault]; + return descriptionString; +} + +@end + @implementation MTRDemandResponseLoadControlClusterHeatingSourceControlStruct - (instancetype)init { diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp index 8e121e8c752fbb..1ec7df481fdc37 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp @@ -8948,6 +8948,761 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) } // namespace Attributes } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { +namespace Attributes { + +namespace SensitivityLevel { + +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +} // namespace SensitivityLevel + +namespace AlarmsActive { + +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE); +} + +} // namespace AlarmsActive + +namespace AlarmsSuppressed { + +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE); +} + +} // namespace AlarmsSuppressed + +namespace AlarmsEnabled { + +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, writable, ZCL_BITMAP8_ATTRIBUTE_TYPE); +} + +} // namespace AlarmsEnabled + +namespace FeatureMap { + +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace FeatureMap + +namespace ClusterRevision { + +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::BooleanSensorConfiguration::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); +} + +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace BooleanSensorConfiguration + +namespace ValveConfigurationAndControl { +namespace Attributes { + +namespace OpenDuration { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace OpenDuration + +namespace AutoCloseTime { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_EPOCH_US_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace AutoCloseTime + +namespace RemainingDuration { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ELAPSED_S_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace RemainingDuration + +namespace CurrentState { + +EmberAfStatus Get(chip::EndpointId endpoint, + DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, + const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace CurrentState + +namespace TargetState { + +EmberAfStatus Get(chip::EndpointId endpoint, + DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, + const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace TargetState + +namespace StartUpState { + +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_ENUM8_ATTRIBUTE_TYPE); +} + +} // namespace StartUpState + +namespace CurrentLevel { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace CurrentLevel + +namespace TargetLevel { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace TargetLevel + +namespace OpenLevel { + +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (Traits::IsNullValue(temp)) + { + value.SetNull(); + } + else + { + value.SetNonNull() = Traits::StorageToWorking(temp); + } + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ true, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE); +} + +EmberAfStatus SetNull(chip::EndpointId endpoint) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType value; + Traits::SetNull(value); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(value); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_PERCENT_ATTRIBUTE_TYPE); +} + +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value) +{ + if (value.IsNull()) + { + return SetNull(endpoint); + } + + return Set(endpoint, value.Value()); +} + +} // namespace OpenLevel + +namespace ValveFault { + +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, + chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_BITMAP16_ATTRIBUTE_TYPE); +} + +} // namespace ValveFault + +namespace FeatureMap { + +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace FeatureMap + +namespace ClusterRevision { + +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::ValveConfigurationAndControl::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); +} + +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace ValveConfigurationAndControl + namespace DemandResponseLoadControl { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h index 9281745811e65f..5d55df3d0ace1e 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h @@ -1751,6 +1751,135 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Attributes } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { +namespace Attributes { + +namespace SensitivityLevel { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum * value); // SensitivityEnum +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum value); +} // namespace SensitivityLevel + +namespace AlarmsActive { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value); // AlarmModeBitmap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace AlarmsActive + +namespace AlarmsSuppressed { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value); // AlarmModeBitmap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace AlarmsSuppressed + +namespace AlarmsEnabled { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value); // AlarmModeBitmap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace AlarmsEnabled + +namespace FeatureMap { +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); +} // namespace FeatureMap + +namespace ClusterRevision { +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace BooleanSensorConfiguration + +namespace ValveConfigurationAndControl { +namespace Attributes { + +namespace OpenDuration { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // elapsed_s +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); +} // namespace OpenDuration + +namespace AutoCloseTime { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us +EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); +} // namespace AutoCloseTime + +namespace RemainingDuration { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // elapsed_s +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); +} // namespace RemainingDuration + +namespace CurrentState { +EmberAfStatus Get(chip::EndpointId endpoint, + DataModel::Nullable & value); // ValveStateEnum +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, + const chip::app::DataModel::Nullable & value); +} // namespace CurrentState + +namespace TargetState { +EmberAfStatus Get(chip::EndpointId endpoint, + DataModel::Nullable & value); // ValveStateEnum +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, + const chip::app::DataModel::Nullable & value); +} // namespace TargetState + +namespace StartUpState { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum * value); // ValveStateEnum +EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value); +} // namespace StartUpState + +namespace CurrentLevel { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // percent +EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); +} // namespace CurrentLevel + +namespace TargetLevel { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // percent +EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); +} // namespace TargetLevel + +namespace OpenLevel { +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // percent +EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value); +EmberAfStatus SetNull(chip::EndpointId endpoint); +EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); +} // namespace OpenLevel + +namespace ValveFault { +EmberAfStatus Get(chip::EndpointId endpoint, + chip::BitMask * value); // ValveFaultBitmap +EmberAfStatus Set(chip::EndpointId endpoint, + chip::BitMask value); +} // namespace ValveFault + +namespace FeatureMap { +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); +} // namespace FeatureMap + +namespace ClusterRevision { +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace ValveConfigurationAndControl + namespace DemandResponseLoadControl { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h index c3e928f001d2b5..43ea13397f8a63 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -513,6 +513,22 @@ void emberAfHepaFilterMonitoringClusterInitCallback(chip::EndpointId endpoint); */ void emberAfActivatedCarbonFilterMonitoringClusterInitCallback(chip::EndpointId endpoint); +/** @brief Boolean Sensor Configuration Cluster Init + * + * Cluster Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfBooleanSensorConfigurationClusterInitCallback(chip::EndpointId endpoint); + +/** @brief Valve Configuration and Control Cluster Init + * + * Cluster Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfValveConfigurationAndControlClusterInitCallback(chip::EndpointId endpoint); + /** @brief Demand Response Load Control Cluster Init * * Cluster Init @@ -5482,6 +5498,159 @@ void emberAfActivatedCarbonFilterMonitoringClusterServerTickCallback(chip::Endpo */ void emberAfActivatedCarbonFilterMonitoringClusterClientTickCallback(chip::EndpointId endpoint); +// +// Boolean Sensor Configuration Cluster +// + +/** @brief Boolean Sensor Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfBooleanSensorConfigurationClusterServerInitCallback(chip::EndpointId endpoint); + +/** @brief Boolean Sensor Configuration Cluster Server Shutdown + * + * Server Shutdown + * + * @param endpoint Endpoint that is being shutdown + */ +void MatterBooleanSensorConfigurationClusterServerShutdownCallback(chip::EndpointId endpoint); + +/** @brief Boolean Sensor Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfBooleanSensorConfigurationClusterClientInitCallback(chip::EndpointId endpoint); + +/** @brief Boolean Sensor Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param attributePath Concrete attribute path that changed + */ +void MatterBooleanSensorConfigurationClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath); + +/** @brief Boolean Sensor Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status MatterBooleanSensorConfigurationClusterServerPreAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** @brief Boolean Sensor Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status MatterBooleanSensorConfigurationClusterClientPreAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** @brief Boolean Sensor Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served + */ +void emberAfBooleanSensorConfigurationClusterServerTickCallback(chip::EndpointId endpoint); + +/** @brief Boolean Sensor Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served + */ +void emberAfBooleanSensorConfigurationClusterClientTickCallback(chip::EndpointId endpoint); + +// +// Valve Configuration and Control Cluster +// + +/** @brief Valve Configuration and Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfValveConfigurationAndControlClusterServerInitCallback(chip::EndpointId endpoint); + +/** @brief Valve Configuration and Control Cluster Server Shutdown + * + * Server Shutdown + * + * @param endpoint Endpoint that is being shutdown + */ +void MatterValveConfigurationAndControlClusterServerShutdownCallback(chip::EndpointId endpoint); + +/** @brief Valve Configuration and Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfValveConfigurationAndControlClusterClientInitCallback(chip::EndpointId endpoint); + +/** @brief Valve Configuration and Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param attributePath Concrete attribute path that changed + */ +void MatterValveConfigurationAndControlClusterServerAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath); + +/** @brief Valve Configuration and Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status MatterValveConfigurationAndControlClusterServerPreAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** @brief Valve Configuration and Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status MatterValveConfigurationAndControlClusterClientPreAttributeChangedCallback( + const chip::app::ConcreteAttributePath & attributePath, EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** @brief Valve Configuration and Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served + */ +void emberAfValveConfigurationAndControlClusterServerTickCallback(chip::EndpointId endpoint); + +/** @brief Valve Configuration and Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served + */ +void emberAfValveConfigurationAndControlClusterClientTickCallback(chip::EndpointId endpoint); + // // Demand Response Load Control Cluster // @@ -9231,6 +9400,30 @@ bool emberAfMicrowaveOvenControlClusterSetCookingParametersCallback( bool emberAfMicrowaveOvenControlClusterAddMoreTimeCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::MicrowaveOvenControl::Commands::AddMoreTime::DecodableType & commandData); +/** + * @brief Boolean Sensor Configuration Cluster SuppressRequest Command callback (from client) + */ +bool emberAfBooleanSensorConfigurationClusterSuppressRequestCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::DecodableType & commandData); +/** + * @brief Valve Configuration and Control Cluster Open Command callback (from client) + */ +bool emberAfValveConfigurationAndControlClusterOpenCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::DecodableType & commandData); +/** + * @brief Valve Configuration and Control Cluster Close Command callback (from client) + */ +bool emberAfValveConfigurationAndControlClusterCloseCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::DecodableType & commandData); +/** + * @brief Valve Configuration and Control Cluster SetLevel Command callback (from client) + */ +bool emberAfValveConfigurationAndControlClusterSetLevelCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::DecodableType & commandData); /** * @brief Demand Response Load Control Cluster RegisterLoadControlProgramRequest Command callback (from client) */ diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h index 12aa4e979eced3..8fead3064af24a 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h @@ -1457,6 +1457,33 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(ActivatedCarbonFilterMo } } +static auto __attribute__((unused)) EnsureKnownEnumValue(BooleanSensorConfiguration::SensitivityEnum val) +{ + using EnumType = BooleanSensorConfiguration::SensitivityEnum; + switch (val) + { + case EnumType::kHigh: + case EnumType::kStandard: + case EnumType::kLow: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ValveConfigurationAndControl::ValveStateEnum val) +{ + using EnumType = ValveConfigurationAndControl::ValveStateEnum; + switch (val) + { + case EnumType::kOpen: + case EnumType::kClosed: + return val; + default: + return static_cast(2); + } +} + static auto __attribute__((unused)) EnsureKnownEnumValue(DemandResponseLoadControl::CriticalityLevelEnum val) { using EnumType = DemandResponseLoadControl::CriticalityLevelEnum; diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index 09296a46c2d8ca..2a6125ed5310c9 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -2056,6 +2056,68 @@ enum class Feature : uint32_t }; } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { + +// Enum for SensitivityEnum +enum class SensitivityEnum : uint8_t +{ + kHigh = 0x00, + kStandard = 0x01, + kLow = 0x02, + // All received enum values that are not listed above will be mapped + // to kUnknownEnumValue. This is a helper enum value that should only + // be used by code to process how it handles receiving and unknown + // enum value. This specific should never be transmitted. + kUnknownEnumValue = 3, +}; + +// Bitmap for AlarmModeBitmap +enum class AlarmModeBitmap : uint8_t +{ + kVisual = 0x1, + kAudible = 0x2, +}; + +// Bitmap for Feature +enum class Feature : uint32_t +{ + kVisual = 0x1, + kAudible = 0x2, + kAlarmSuppress = 0x4, + kSensitivityLevel = 0x8, +}; +} // namespace BooleanSensorConfiguration + +namespace ValveConfigurationAndControl { + +// Enum for ValveStateEnum +enum class ValveStateEnum : uint8_t +{ + kOpen = 0x00, + kClosed = 0x01, + // All received enum values that are not listed above will be mapped + // to kUnknownEnumValue. This is a helper enum value that should only + // be used by code to process how it handles receiving and unknown + // enum value. This specific should never be transmitted. + kUnknownEnumValue = 2, +}; + +// Bitmap for Feature +enum class Feature : uint32_t +{ + kTimeSync = 0x1, + kLevel = 0x2, +}; + +// Bitmap for ValveFaultBitmap +enum class ValveFaultBitmap : uint16_t +{ + kGeneralFault = 0x1, + kBlocked = 0x2, + kLeaking = 0x4, +}; +} // namespace ValveConfigurationAndControl + namespace DemandResponseLoadControl { // Enum for CriticalityLevelEnum diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 428f781aaf164c..cf4774e9bdd0cd 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -13138,6 +13138,356 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre namespace Events {} // namespace Events } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { + +namespace Commands { +namespace SuppressRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kAlarmsToSuppress), alarmsToSuppress); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kAlarmsToSuppress)) + { + err = DataModel::Decode(reader, alarmsToSuppress); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SuppressRequest. +} // namespace Commands + +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::SensitivityLevel::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, sensitivityLevel); + case Attributes::AlarmsActive::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, alarmsActive); + case Attributes::AlarmsSuppressed::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, alarmsSuppressed); + case Attributes::AlarmsEnabled::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, alarmsEnabled); + case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, generatedCommandList); + case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, acceptedCommandList); + case Attributes::EventList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, eventList); + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, attributeList); + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, featureMap); + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, clusterRevision); + default: + return CHIP_NO_ERROR; + } +} +} // namespace Attributes + +namespace Events { +namespace AlarmsStateChanged { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmsActive), alarmsActive)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kAlarmsSuppressed), alarmsSuppressed)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kAlarmsActive)) + { + err = DataModel::Decode(reader, alarmsActive); + } + else if (__context_tag == to_underlying(Fields::kAlarmsSuppressed)) + { + err = DataModel::Decode(reader, alarmsSuppressed); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace AlarmsStateChanged. +namespace SensorFault { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + } +} +} // namespace SensorFault. +} // namespace Events + +} // namespace BooleanSensorConfiguration +namespace ValveConfigurationAndControl { + +namespace Commands { +namespace Open { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kOpenDuration), openDuration); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kOpenDuration)) + { + err = DataModel::Decode(reader, openDuration); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace Open. +namespace Close { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + } +} +} // namespace Close. +namespace SetLevel { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kLevel), level); + encoder.Encode(to_underlying(Fields::kOpenDuration), openDuration); + return encoder.Finalize(); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kLevel)) + { + err = DataModel::Decode(reader, level); + } + else if (__context_tag == to_underlying(Fields::kOpenDuration)) + { + err = DataModel::Decode(reader, openDuration); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SetLevel. +} // namespace Commands + +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::OpenDuration::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, openDuration); + case Attributes::AutoCloseTime::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, autoCloseTime); + case Attributes::RemainingDuration::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, remainingDuration); + case Attributes::CurrentState::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, currentState); + case Attributes::TargetState::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, targetState); + case Attributes::StartUpState::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, startUpState); + case Attributes::CurrentLevel::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, currentLevel); + case Attributes::TargetLevel::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, targetLevel); + case Attributes::OpenLevel::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, openLevel); + case Attributes::ValveFault::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, valveFault); + case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, generatedCommandList); + case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, acceptedCommandList); + case Attributes::EventList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, eventList); + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, attributeList); + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, featureMap); + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, clusterRevision); + default: + return CHIP_NO_ERROR; + } +} +} // namespace Attributes + +namespace Events { +namespace ValveStateChanged { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveState), valveState)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kValveState)) + { + err = DataModel::Decode(reader, valveState); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace ValveStateChanged. +namespace ValveFault { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kValveFault), valveFault)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kValveFault)) + { + err = DataModel::Decode(reader, valveFault); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace ValveFault. +} // namespace Events + +} // namespace ValveConfigurationAndControl namespace DemandResponseLoadControl { namespace Structs { @@ -24119,6 +24469,20 @@ bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand) return false; } } + case Clusters::BooleanSensorConfiguration::Id: { + switch (aCommand) + { + default: + return false; + } + } + case Clusters::ValveConfigurationAndControl::Id: { + switch (aCommand) + { + default: + return false; + } + } case Clusters::DemandResponseLoadControl::Id: { switch (aCommand) { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index fe3f44d048064c..28f768cb0874be 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -18721,6 +18721,611 @@ struct TypeInfo }; } // namespace Attributes } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { + +namespace Commands { +// Forward-declarations so we can reference these later. + +namespace SuppressRequest { +struct Type; +struct DecodableType; +} // namespace SuppressRequest + +} // namespace Commands + +namespace Commands { +namespace SuppressRequest { +enum class Fields : uint8_t +{ + kAlarmsToSuppress = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SuppressRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + + chip::BitMask alarmsToSuppress = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SuppressRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + + chip::BitMask alarmsToSuppress = static_cast>(0); + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SuppressRequest +} // namespace Commands + +namespace Attributes { + +namespace SensitivityLevel { +struct TypeInfo +{ + using Type = chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum; + using DecodableType = chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum; + using DecodableArgType = chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum; + + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::SensitivityLevel::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace SensitivityLevel +namespace AlarmsActive { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsActive::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace AlarmsActive +namespace AlarmsSuppressed { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsSuppressed::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace AlarmsSuppressed +namespace AlarmsEnabled { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::AlarmsEnabled::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace AlarmsEnabled +namespace GeneratedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } +}; +} // namespace GeneratedCommandList +namespace AcceptedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } +}; +} // namespace AcceptedCommandList +namespace EventList { +struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } +}; +} // namespace EventList +namespace AttributeList { +struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } +}; +} // namespace AttributeList +namespace FeatureMap { +struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } +}; +} // namespace FeatureMap +namespace ClusterRevision { +struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } +}; +} // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::SensitivityLevel::TypeInfo::DecodableType sensitivityLevel = + static_cast(0); + Attributes::AlarmsActive::TypeInfo::DecodableType alarmsActive = + static_cast>(0); + Attributes::AlarmsSuppressed::TypeInfo::DecodableType alarmsSuppressed = + static_cast>(0); + Attributes::AlarmsEnabled::TypeInfo::DecodableType alarmsEnabled = + static_cast>(0); + Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; + Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; + Attributes::EventList::TypeInfo::DecodableType eventList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast(0); + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast(0); + }; +}; +} // namespace Attributes +namespace Events { +namespace AlarmsStateChanged { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kAlarmsActive = 0, + kAlarmsSuppressed = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::AlarmsStateChanged::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask alarmsActive = static_cast>(0); + Optional> alarmsSuppressed; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::AlarmsStateChanged::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + + chip::BitMask alarmsActive = static_cast>(0); + Optional> alarmsSuppressed; + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace AlarmsStateChanged +namespace SensorFault { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SensorFault::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SensorFault::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::BooleanSensorConfiguration::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace SensorFault +} // namespace Events +} // namespace BooleanSensorConfiguration +namespace ValveConfigurationAndControl { + +namespace Commands { +// Forward-declarations so we can reference these later. + +namespace Open { +struct Type; +struct DecodableType; +} // namespace Open + +namespace Close { +struct Type; +struct DecodableType; +} // namespace Close + +namespace SetLevel { +struct Type; +struct DecodableType; +} // namespace SetLevel + +} // namespace Commands + +namespace Commands { +namespace Open { +enum class Fields : uint8_t +{ + kOpenDuration = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::Open::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + Optional openDuration; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::Open::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + Optional openDuration; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace Open +namespace Close { +enum class Fields : uint8_t +{ +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::Close::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::Close::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace Close +namespace SetLevel { +enum class Fields : uint8_t +{ + kLevel = 0, + kOpenDuration = 1, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SetLevel::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + chip::Percent level = static_cast(0); + Optional openDuration; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SetLevel::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + chip::Percent level = static_cast(0); + Optional openDuration; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SetLevel +} // namespace Commands + +namespace Attributes { + +namespace OpenDuration { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::OpenDuration::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace OpenDuration +namespace AutoCloseTime { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::AutoCloseTime::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace AutoCloseTime +namespace RemainingDuration { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::RemainingDuration::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace RemainingDuration +namespace CurrentState { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = + const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::CurrentState::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace CurrentState +namespace TargetState { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = + const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::TargetState::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace TargetState +namespace StartUpState { +struct TypeInfo +{ + using Type = chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum; + using DecodableType = chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum; + using DecodableArgType = chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::StartUpState::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace StartUpState +namespace CurrentLevel { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLevel::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace CurrentLevel +namespace TargetLevel { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::TargetLevel::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace TargetLevel +namespace OpenLevel { +struct TypeInfo +{ + using Type = chip::app::DataModel::Nullable; + using DecodableType = chip::app::DataModel::Nullable; + using DecodableArgType = const chip::app::DataModel::Nullable &; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::OpenLevel::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace OpenLevel +namespace ValveFault { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::ValveFault::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace ValveFault +namespace GeneratedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } +}; +} // namespace GeneratedCommandList +namespace AcceptedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } +}; +} // namespace AcceptedCommandList +namespace EventList { +struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } +}; +} // namespace EventList +namespace AttributeList { +struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } +}; +} // namespace AttributeList +namespace FeatureMap { +struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } +}; +} // namespace FeatureMap +namespace ClusterRevision { +struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } +}; +} // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::OpenDuration::TypeInfo::DecodableType openDuration; + Attributes::AutoCloseTime::TypeInfo::DecodableType autoCloseTime; + Attributes::RemainingDuration::TypeInfo::DecodableType remainingDuration; + Attributes::CurrentState::TypeInfo::DecodableType currentState; + Attributes::TargetState::TypeInfo::DecodableType targetState; + Attributes::StartUpState::TypeInfo::DecodableType startUpState = + static_cast(0); + Attributes::CurrentLevel::TypeInfo::DecodableType currentLevel; + Attributes::TargetLevel::TypeInfo::DecodableType targetLevel; + Attributes::OpenLevel::TypeInfo::DecodableType openLevel; + Attributes::ValveFault::TypeInfo::DecodableType valveFault = + static_cast>(0); + Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; + Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; + Attributes::EventList::TypeInfo::DecodableType eventList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast(0); + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast(0); + }; +}; +} // namespace Attributes +namespace Events { +namespace ValveStateChanged { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kValveState = 0, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ValveStateChanged::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr bool kIsFabricScoped = false; + + ValveStateEnum valveState = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ValveStateChanged::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + ValveStateEnum valveState = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace ValveStateChanged +namespace ValveFault { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kValveFault = 0, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ValveFault::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask valveFault = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ValveFault::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::ValveConfigurationAndControl::Id; } + + chip::BitMask valveFault = static_cast>(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace ValveFault +} // namespace Events +} // namespace ValveConfigurationAndControl namespace DemandResponseLoadControl { namespace Structs { namespace HeatingSourceControlStruct { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h index 36323d8644bac2..19f01348b3d052 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h @@ -3367,6 +3367,122 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; } // namespace Attributes } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { +namespace Attributes { + +namespace SensitivityLevel { +static constexpr AttributeId Id = 0x00000000; +} // namespace SensitivityLevel + +namespace AlarmsActive { +static constexpr AttributeId Id = 0x00000001; +} // namespace AlarmsActive + +namespace AlarmsSuppressed { +static constexpr AttributeId Id = 0x00000002; +} // namespace AlarmsSuppressed + +namespace AlarmsEnabled { +static constexpr AttributeId Id = 0x00000003; +} // namespace AlarmsEnabled + +namespace GeneratedCommandList { +static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id; +} // namespace GeneratedCommandList + +namespace AcceptedCommandList { +static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id; +} // namespace AcceptedCommandList + +namespace EventList { +static constexpr AttributeId Id = Globals::Attributes::EventList::Id; +} // namespace EventList + +namespace AttributeList { +static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id; +} // namespace AttributeList + +namespace FeatureMap { +static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id; +} // namespace FeatureMap + +namespace ClusterRevision { +static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace BooleanSensorConfiguration + +namespace ValveConfigurationAndControl { +namespace Attributes { + +namespace OpenDuration { +static constexpr AttributeId Id = 0x00000000; +} // namespace OpenDuration + +namespace AutoCloseTime { +static constexpr AttributeId Id = 0x00000001; +} // namespace AutoCloseTime + +namespace RemainingDuration { +static constexpr AttributeId Id = 0x00000002; +} // namespace RemainingDuration + +namespace CurrentState { +static constexpr AttributeId Id = 0x00000003; +} // namespace CurrentState + +namespace TargetState { +static constexpr AttributeId Id = 0x00000004; +} // namespace TargetState + +namespace StartUpState { +static constexpr AttributeId Id = 0x00000005; +} // namespace StartUpState + +namespace CurrentLevel { +static constexpr AttributeId Id = 0x00000006; +} // namespace CurrentLevel + +namespace TargetLevel { +static constexpr AttributeId Id = 0x00000007; +} // namespace TargetLevel + +namespace OpenLevel { +static constexpr AttributeId Id = 0x00000008; +} // namespace OpenLevel + +namespace ValveFault { +static constexpr AttributeId Id = 0x00000009; +} // namespace ValveFault + +namespace GeneratedCommandList { +static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id; +} // namespace GeneratedCommandList + +namespace AcceptedCommandList { +static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id; +} // namespace AcceptedCommandList + +namespace EventList { +static constexpr AttributeId Id = Globals::Attributes::EventList::Id; +} // namespace EventList + +namespace AttributeList { +static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id; +} // namespace AttributeList + +namespace FeatureMap { +static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id; +} // namespace FeatureMap + +namespace ClusterRevision { +static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace ValveConfigurationAndControl + namespace DemandResponseLoadControl { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h index c5ec35da15c8b3..bfc96bf1c6880e 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h @@ -205,6 +205,12 @@ static constexpr ClusterId Id = 0x00000071; namespace ActivatedCarbonFilterMonitoring { static constexpr ClusterId Id = 0x00000072; } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { +static constexpr ClusterId Id = 0x00000080; +} // namespace BooleanSensorConfiguration +namespace ValveConfigurationAndControl { +static constexpr ClusterId Id = 0x00000081; +} // namespace ValveConfigurationAndControl namespace DemandResponseLoadControl { static constexpr ClusterId Id = 0x00000096; } // namespace DemandResponseLoadControl diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h index 97129ac5f2168b..22cba33dd50641 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h @@ -869,6 +869,34 @@ static constexpr CommandId Id = 0x00000000; } // namespace Commands } // namespace ActivatedCarbonFilterMonitoring +namespace BooleanSensorConfiguration { +namespace Commands { + +namespace SuppressRequest { +static constexpr CommandId Id = 0x00000000; +} // namespace SuppressRequest + +} // namespace Commands +} // namespace BooleanSensorConfiguration + +namespace ValveConfigurationAndControl { +namespace Commands { + +namespace Open { +static constexpr CommandId Id = 0x00000000; +} // namespace Open + +namespace Close { +static constexpr CommandId Id = 0x00000001; +} // namespace Close + +namespace SetLevel { +static constexpr CommandId Id = 0x00000002; +} // namespace SetLevel + +} // namespace Commands +} // namespace ValveConfigurationAndControl + namespace DemandResponseLoadControl { namespace Commands { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h index d77938228e2f27..1a019ac83d5bf5 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h @@ -365,6 +365,34 @@ static constexpr EventId Id = 0x00000001; } // namespace Events } // namespace RvcOperationalState +namespace BooleanSensorConfiguration { +namespace Events { + +namespace AlarmsStateChanged { +static constexpr EventId Id = 0x00000000; +} // namespace AlarmsStateChanged + +namespace SensorFault { +static constexpr EventId Id = 0x00000001; +} // namespace SensorFault + +} // namespace Events +} // namespace BooleanSensorConfiguration + +namespace ValveConfigurationAndControl { +namespace Events { + +namespace ValveStateChanged { +static constexpr EventId Id = 0x00000000; +} // namespace ValveStateChanged + +namespace ValveFault { +static constexpr EventId Id = 0x00000001; +} // namespace ValveFault + +} // namespace Events +} // namespace ValveConfigurationAndControl + namespace DemandResponseLoadControl { namespace Events { diff --git a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h index 2827dd0736a05c..ed6730074e62f5 100644 --- a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h +++ b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h @@ -408,6 +408,21 @@ #define CHIP_PRINTCLUSTER_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER #endif +#if defined(ZCL_USING_BOOLEAN_SENSOR_CONFIGURATION_CLUSTER_SERVER) || defined(ZCL_USING_BOOLEAN_SENSOR_CONFIGURATION_CLUSTER_CLIENT) +#define CHIP_PRINTCLUSTER_BOOLEAN_SENSOR_CONFIGURATION_CLUSTER \ + { chip::app::Clusters::BooleanSensorConfiguration::Id, "Boolean Sensor Configuration" }, +#else +#define CHIP_PRINTCLUSTER_BOOLEAN_SENSOR_CONFIGURATION_CLUSTER +#endif + +#if defined(ZCL_USING_VALVE_CONFIGURATION_AND_CONTROL_CLUSTER_SERVER) || \ + defined(ZCL_USING_VALVE_CONFIGURATION_AND_CONTROL_CLUSTER_CLIENT) +#define CHIP_PRINTCLUSTER_VALVE_CONFIGURATION_AND_CONTROL_CLUSTER \ + { chip::app::Clusters::ValveConfigurationAndControl::Id, "Valve Configuration and Control" }, +#else +#define CHIP_PRINTCLUSTER_VALVE_CONFIGURATION_AND_CONTROL_CLUSTER +#endif + #if defined(ZCL_USING_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_SERVER) || defined(ZCL_USING_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_CLIENT) #define CHIP_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ { chip::app::Clusters::DemandResponseLoadControl::Id, "Demand Response Load Control" }, @@ -752,6 +767,8 @@ CHIP_PRINTCLUSTER_OPERATIONAL_STATE_RVC_CLUSTER \ CHIP_PRINTCLUSTER_HEPA_FILTER_MONITORING_CLUSTER \ CHIP_PRINTCLUSTER_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER \ + CHIP_PRINTCLUSTER_BOOLEAN_SENSOR_CONFIGURATION_CLUSTER \ + CHIP_PRINTCLUSTER_VALVE_CONFIGURATION_AND_CONTROL_CLUSTER \ CHIP_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ CHIP_PRINTCLUSTER_DOOR_LOCK_CLUSTER \ CHIP_PRINTCLUSTER_WINDOW_COVERING_CLUSTER \ diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 71641c77d24c98..4f62907c3a6067 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -94,6 +94,8 @@ | RvcOperationalState | 0x0061 | | HepaFilterMonitoring | 0x0071 | | ActivatedCarbonFilterMonitoring | 0x0072 | +| BooleanSensorConfiguration | 0x0080 | +| ValveConfigurationAndControl | 0x0081 | | DemandResponseLoadControl | 0x0096 | | DoorLock | 0x0101 | | WindowCovering | 0x0102 | @@ -6110,6 +6112,210 @@ class ActivatedCarbonFilterMonitoringResetCondition : public ClusterCommand chip::app::Clusters::ActivatedCarbonFilterMonitoring::Commands::ResetCondition::Type mRequest; }; +/*----------------------------------------------------------------------------*\ +| Cluster BooleanSensorConfiguration | 0x0080 | +|------------------------------------------------------------------------------| +| Commands: | | +| * SuppressRequest | 0x00 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * SensitivityLevel | 0x0000 | +| * AlarmsActive | 0x0001 | +| * AlarmsSuppressed | 0x0002 | +| * AlarmsEnabled | 0x0003 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +| * AlarmsStateChanged | 0x0000 | +| * SensorFault | 0x0001 | +\*----------------------------------------------------------------------------*/ + +/* + * Command SuppressRequest + */ +class BooleanSensorConfigurationSuppressRequest : public ClusterCommand +{ +public: + BooleanSensorConfigurationSuppressRequest(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("suppress-request", credsIssuerConfig) + { + AddArgument("AlarmsToSuppress", 0, UINT8_MAX, &mRequest.alarmsToSuppress); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::Type mRequest; +}; + +/*----------------------------------------------------------------------------*\ +| Cluster ValveConfigurationAndControl | 0x0081 | +|------------------------------------------------------------------------------| +| Commands: | | +| * Open | 0x00 | +| * Close | 0x01 | +| * SetLevel | 0x02 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * OpenDuration | 0x0000 | +| * AutoCloseTime | 0x0001 | +| * RemainingDuration | 0x0002 | +| * CurrentState | 0x0003 | +| * TargetState | 0x0004 | +| * StartUpState | 0x0005 | +| * CurrentLevel | 0x0006 | +| * TargetLevel | 0x0007 | +| * OpenLevel | 0x0008 | +| * ValveFault | 0x0009 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +| * ValveStateChanged | 0x0000 | +| * ValveFault | 0x0001 | +\*----------------------------------------------------------------------------*/ + +/* + * Command Open + */ +class ValveConfigurationAndControlOpen : public ClusterCommand +{ +public: + ValveConfigurationAndControlOpen(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("open", credsIssuerConfig) + { + AddArgument("OpenDuration", 0, UINT32_MAX, &mRequest.openDuration); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Type mRequest; +}; + +/* + * Command Close + */ +class ValveConfigurationAndControlClose : public ClusterCommand +{ +public: + ValveConfigurationAndControlClose(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("close", credsIssuerConfig) + { + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Type mRequest; +}; + +/* + * Command SetLevel + */ +class ValveConfigurationAndControlSetLevel : public ClusterCommand +{ +public: + ValveConfigurationAndControlSetLevel(CredentialIssuerCommands * credsIssuerConfig) : + ClusterCommand("set-level", credsIssuerConfig) + { + AddArgument("Level", 0, UINT8_MAX, &mRequest.level); + AddArgument("OpenDuration", 0, UINT32_MAX, &mRequest.openDuration); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, + commandId, endpointIds.at(0)); + return ClusterCommand::SendCommand(device, endpointIds.at(0), clusterId, commandId, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on Group %u", clusterId, commandId, + groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, clusterId, commandId, mRequest); + } + +private: + chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::Type mRequest; +}; + /*----------------------------------------------------------------------------*\ | Cluster DemandResponseLoadControl | 0x0096 | |------------------------------------------------------------------------------| @@ -17094,6 +17300,182 @@ void registerClusterActivatedCarbonFilterMonitoring(Commands & commands, Credent commands.RegisterCluster(clusterName, clusterCommands); } +void registerClusterBooleanSensorConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) +{ + using namespace chip::app::Clusters::BooleanSensorConfiguration; + + const char * clusterName = "BooleanSensorConfiguration"; + + commands_list clusterCommands = { + // + // Commands + // + make_unique(Id, credsIssuerConfig), // + make_unique(credsIssuerConfig), // + // + // Attributes + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "sensitivity-level", Attributes::SensitivityLevel::Id, credsIssuerConfig), // + make_unique(Id, "alarms-active", Attributes::AlarmsActive::Id, credsIssuerConfig), // + make_unique(Id, "alarms-suppressed", Attributes::AlarmsSuppressed::Id, credsIssuerConfig), // + make_unique(Id, "alarms-enabled", Attributes::AlarmsEnabled::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + make_unique>(Id, credsIssuerConfig), // + make_unique>( + Id, "sensitivity-level", 0, UINT8_MAX, Attributes::SensitivityLevel::Id, WriteCommandType::kWrite, + credsIssuerConfig), // + make_unique>>( + Id, "alarms-active", 0, UINT8_MAX, Attributes::AlarmsActive::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "alarms-suppressed", 0, UINT8_MAX, Attributes::AlarmsSuppressed::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>>( + Id, "alarms-enabled", 0, UINT8_MAX, Attributes::AlarmsEnabled::Id, WriteCommandType::kWrite, credsIssuerConfig), // + make_unique>>( + Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>>( + Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "sensitivity-level", Attributes::SensitivityLevel::Id, credsIssuerConfig), // + make_unique(Id, "alarms-active", Attributes::AlarmsActive::Id, credsIssuerConfig), // + make_unique(Id, "alarms-suppressed", Attributes::AlarmsSuppressed::Id, credsIssuerConfig), // + make_unique(Id, "alarms-enabled", Attributes::AlarmsEnabled::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + // + // Events + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "alarms-state-changed", Events::AlarmsStateChanged::Id, credsIssuerConfig), // + make_unique(Id, "sensor-fault", Events::SensorFault::Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "alarms-state-changed", Events::AlarmsStateChanged::Id, credsIssuerConfig), // + make_unique(Id, "sensor-fault", Events::SensorFault::Id, credsIssuerConfig), // + }; + + commands.RegisterCluster(clusterName, clusterCommands); +} +void registerClusterValveConfigurationAndControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) +{ + using namespace chip::app::Clusters::ValveConfigurationAndControl; + + const char * clusterName = "ValveConfigurationAndControl"; + + commands_list clusterCommands = { + // + // Commands + // + make_unique(Id, credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // + // + // Attributes + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "open-duration", Attributes::OpenDuration::Id, credsIssuerConfig), // + make_unique(Id, "auto-close-time", Attributes::AutoCloseTime::Id, credsIssuerConfig), // + make_unique(Id, "remaining-duration", Attributes::RemainingDuration::Id, credsIssuerConfig), // + make_unique(Id, "current-state", Attributes::CurrentState::Id, credsIssuerConfig), // + make_unique(Id, "target-state", Attributes::TargetState::Id, credsIssuerConfig), // + make_unique(Id, "start-up-state", Attributes::StartUpState::Id, credsIssuerConfig), // + make_unique(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig), // + make_unique(Id, "target-level", Attributes::TargetLevel::Id, credsIssuerConfig), // + make_unique(Id, "open-level", Attributes::OpenLevel::Id, credsIssuerConfig), // + make_unique(Id, "valve-fault", Attributes::ValveFault::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + make_unique>(Id, credsIssuerConfig), // + make_unique>>( + Id, "open-duration", 0, UINT32_MAX, Attributes::OpenDuration::Id, WriteCommandType::kWrite, credsIssuerConfig), // + make_unique>>(Id, "auto-close-time", 0, UINT64_MAX, + Attributes::AutoCloseTime::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>(Id, "remaining-duration", 0, UINT32_MAX, + Attributes::RemainingDuration::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique< + WriteAttribute>>( + Id, "current-state", 0, UINT8_MAX, Attributes::CurrentState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique< + WriteAttribute>>( + Id, "target-state", 0, UINT8_MAX, Attributes::TargetState::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>( + Id, "start-up-state", 0, UINT8_MAX, Attributes::StartUpState::Id, WriteCommandType::kWrite, credsIssuerConfig), // + make_unique>>( + Id, "current-level", 0, UINT8_MAX, Attributes::CurrentLevel::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "target-level", 0, UINT8_MAX, Attributes::TargetLevel::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "open-level", 0, UINT8_MAX, Attributes::OpenLevel::Id, WriteCommandType::kWrite, credsIssuerConfig), // + make_unique>>( + Id, "valve-fault", 0, UINT16_MAX, Attributes::ValveFault::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>>( + Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "open-duration", Attributes::OpenDuration::Id, credsIssuerConfig), // + make_unique(Id, "auto-close-time", Attributes::AutoCloseTime::Id, credsIssuerConfig), // + make_unique(Id, "remaining-duration", Attributes::RemainingDuration::Id, credsIssuerConfig), // + make_unique(Id, "current-state", Attributes::CurrentState::Id, credsIssuerConfig), // + make_unique(Id, "target-state", Attributes::TargetState::Id, credsIssuerConfig), // + make_unique(Id, "start-up-state", Attributes::StartUpState::Id, credsIssuerConfig), // + make_unique(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig), // + make_unique(Id, "target-level", Attributes::TargetLevel::Id, credsIssuerConfig), // + make_unique(Id, "open-level", Attributes::OpenLevel::Id, credsIssuerConfig), // + make_unique(Id, "valve-fault", Attributes::ValveFault::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + // + // Events + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "valve-state-changed", Events::ValveStateChanged::Id, credsIssuerConfig), // + make_unique(Id, "valve-fault", Events::ValveFault::Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "valve-state-changed", Events::ValveStateChanged::Id, credsIssuerConfig), // + make_unique(Id, "valve-fault", Events::ValveFault::Id, credsIssuerConfig), // + }; + + commands.RegisterCluster(clusterName, clusterCommands); +} void registerClusterDemandResponseLoadControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) { using namespace chip::app::Clusters::DemandResponseLoadControl; @@ -22543,6 +22925,8 @@ void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssue registerClusterRvcOperationalState(commands, credsIssuerConfig); registerClusterHepaFilterMonitoring(commands, credsIssuerConfig); registerClusterActivatedCarbonFilterMonitoring(commands, credsIssuerConfig); + registerClusterBooleanSensorConfiguration(commands, credsIssuerConfig); + registerClusterValveConfigurationAndControl(commands, credsIssuerConfig); registerClusterDemandResponseLoadControl(commands, credsIssuerConfig); registerClusterDoorLock(commands, credsIssuerConfig); registerClusterWindowCovering(commands, credsIssuerConfig); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp index 62bd8c41261e1e..c8ced8445fe0ae 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -4295,6 +4295,70 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const BooleanSensorConfiguration::Events::AlarmsStateChanged::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("AlarmsActive", indent + 1, value.alarmsActive); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'AlarmsActive'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("AlarmsSuppressed", indent + 1, value.alarmsSuppressed); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'AlarmsSuppressed'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const BooleanSensorConfiguration::Events::SensorFault::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const ValveConfigurationAndControl::Events::ValveStateChanged::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("ValveState", indent + 1, value.valveState); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'ValveState'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const ValveConfigurationAndControl::Events::ValveFault::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("ValveFault", indent + 1, value.valveFault); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'ValveFault'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const DemandResponseLoadControl::Events::LoadControlEventStatusChange::DecodableType & value) { @@ -9606,6 +9670,148 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP } break; } + case BooleanSensorConfiguration::Id: { + switch (path.mAttributeId) + { + case BooleanSensorConfiguration::Attributes::SensitivityLevel::Id: { + chip::app::Clusters::BooleanSensorConfiguration::SensitivityEnum value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("SensitivityLevel", 1, value); + } + case BooleanSensorConfiguration::Attributes::AlarmsActive::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AlarmsActive", 1, value); + } + case BooleanSensorConfiguration::Attributes::AlarmsSuppressed::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AlarmsSuppressed", 1, value); + } + case BooleanSensorConfiguration::Attributes::AlarmsEnabled::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AlarmsEnabled", 1, value); + } + case BooleanSensorConfiguration::Attributes::GeneratedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("GeneratedCommandList", 1, value); + } + case BooleanSensorConfiguration::Attributes::AcceptedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AcceptedCommandList", 1, value); + } + case BooleanSensorConfiguration::Attributes::EventList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EventList", 1, value); + } + case BooleanSensorConfiguration::Attributes::AttributeList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AttributeList", 1, value); + } + case BooleanSensorConfiguration::Attributes::FeatureMap::Id: { + uint32_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("FeatureMap", 1, value); + } + case BooleanSensorConfiguration::Attributes::ClusterRevision::Id: { + uint16_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ClusterRevision", 1, value); + } + } + break; + } + case ValveConfigurationAndControl::Id: { + switch (path.mAttributeId) + { + case ValveConfigurationAndControl::Attributes::OpenDuration::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("OpenDuration", 1, value); + } + case ValveConfigurationAndControl::Attributes::AutoCloseTime::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AutoCloseTime", 1, value); + } + case ValveConfigurationAndControl::Attributes::RemainingDuration::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("RemainingDuration", 1, value); + } + case ValveConfigurationAndControl::Attributes::CurrentState::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("CurrentState", 1, value); + } + case ValveConfigurationAndControl::Attributes::TargetState::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("TargetState", 1, value); + } + case ValveConfigurationAndControl::Attributes::StartUpState::Id: { + chip::app::Clusters::ValveConfigurationAndControl::ValveStateEnum value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("StartUpState", 1, value); + } + case ValveConfigurationAndControl::Attributes::CurrentLevel::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("CurrentLevel", 1, value); + } + case ValveConfigurationAndControl::Attributes::TargetLevel::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("TargetLevel", 1, value); + } + case ValveConfigurationAndControl::Attributes::OpenLevel::Id: { + chip::app::DataModel::Nullable value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("OpenLevel", 1, value); + } + case ValveConfigurationAndControl::Attributes::ValveFault::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ValveFault", 1, value); + } + case ValveConfigurationAndControl::Attributes::GeneratedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("GeneratedCommandList", 1, value); + } + case ValveConfigurationAndControl::Attributes::AcceptedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AcceptedCommandList", 1, value); + } + case ValveConfigurationAndControl::Attributes::EventList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EventList", 1, value); + } + case ValveConfigurationAndControl::Attributes::AttributeList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AttributeList", 1, value); + } + case ValveConfigurationAndControl::Attributes::FeatureMap::Id: { + uint32_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("FeatureMap", 1, value); + } + case ValveConfigurationAndControl::Attributes::ClusterRevision::Id: { + uint16_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ClusterRevision", 1, value); + } + } + break; + } case DemandResponseLoadControl::Id: { switch (path.mAttributeId) { @@ -15192,6 +15398,38 @@ CHIP_ERROR DataModelLogger::LogEvent(const chip::app::EventHeader & header, chip } break; } + case BooleanSensorConfiguration::Id: { + switch (header.mPath.mEventId) + { + case BooleanSensorConfiguration::Events::AlarmsStateChanged::Id: { + chip::app::Clusters::BooleanSensorConfiguration::Events::AlarmsStateChanged::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AlarmsStateChanged", 1, value); + } + case BooleanSensorConfiguration::Events::SensorFault::Id: { + chip::app::Clusters::BooleanSensorConfiguration::Events::SensorFault::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("SensorFault", 1, value); + } + } + break; + } + case ValveConfigurationAndControl::Id: { + switch (header.mPath.mEventId) + { + case ValveConfigurationAndControl::Events::ValveStateChanged::Id: { + chip::app::Clusters::ValveConfigurationAndControl::Events::ValveStateChanged::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ValveStateChanged", 1, value); + } + case ValveConfigurationAndControl::Events::ValveFault::Id: { + chip::app::Clusters::ValveConfigurationAndControl::Events::ValveFault::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ValveFault", 1, value); + } + } + break; + } case DemandResponseLoadControl::Id: { switch (header.mPath.mEventId) { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h index fd07c7d7689334..3236fba6b253d7 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -386,6 +386,16 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::RvcOperationalState::Events::OperationCompletion::DecodableType & value); static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::BooleanSensorConfiguration::Events::AlarmsStateChanged::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::BooleanSensorConfiguration::Events::SensorFault::DecodableType & value); +static CHIP_ERROR +LogValue(const char * label, size_t indent, + const chip::app::Clusters::ValveConfigurationAndControl::Events::ValveStateChanged::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::ValveConfigurationAndControl::Events::ValveFault::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::DemandResponseLoadControl::Events::LoadControlEventStatusChange::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h index d99e1e416c97cc..ead45e0139004d 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -97,6 +97,8 @@ | RvcOperationalState | 0x0061 | | HepaFilterMonitoring | 0x0071 | | ActivatedCarbonFilterMonitoring | 0x0072 | +| BooleanSensorConfiguration | 0x0080 | +| ValveConfigurationAndControl | 0x0081 | | DemandResponseLoadControl | 0x0096 | | DoorLock | 0x0101 | | WindowCovering | 0x0102 | @@ -70198,6 +70200,2706 @@ class SubscribeAttributeActivatedCarbonFilterMonitoringClusterRevision : public } }; +#endif // MTR_ENABLE_PROVISIONAL +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/*----------------------------------------------------------------------------*\ +| Cluster BooleanSensorConfiguration | 0x0080 | +|------------------------------------------------------------------------------| +| Commands: | | +| * SuppressRequest | 0x00 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * SensitivityLevel | 0x0000 | +| * AlarmsActive | 0x0001 | +| * AlarmsSuppressed | 0x0002 | +| * AlarmsEnabled | 0x0003 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +| * AlarmsStateChanged | 0x0000 | +| * SensorFault | 0x0001 | +\*----------------------------------------------------------------------------*/ + +#if MTR_ENABLE_PROVISIONAL +/* + * Command SuppressRequest + */ +class BooleanSensorConfigurationSuppressRequest : public ClusterCommand { +public: + BooleanSensorConfigurationSuppressRequest() + : ClusterCommand("suppress-request") + { +#if MTR_ENABLE_PROVISIONAL + AddArgument("AlarmsToSuppress", 0, UINT8_MAX, &mRequest.alarmsToSuppress); +#endif // MTR_ENABLE_PROVISIONAL + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRBooleanSensorConfigurationClusterSuppressRequestParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; +#if MTR_ENABLE_PROVISIONAL + params.alarmsToSuppress = [NSNumber numberWithUnsignedChar:mRequest.alarmsToSuppress.Raw()]; +#endif // MTR_ENABLE_PROVISIONAL + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster suppressRequestWithParams:params completion: + ^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(commandId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::BooleanSensorConfiguration::Commands::SuppressRequest::Type mRequest; +}; + +#endif // MTR_ENABLE_PROVISIONAL + +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute SensitivityLevel + */ +class ReadBooleanSensorConfigurationSensitivityLevel : public ReadAttribute { +public: + ReadBooleanSensorConfigurationSensitivityLevel() + : ReadAttribute("sensitivity-level") + { + } + + ~ReadBooleanSensorConfigurationSensitivityLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::SensitivityLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeSensitivityLevelWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.SensitivityLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration SensitivityLevel read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteBooleanSensorConfigurationSensitivityLevel : public WriteAttribute { +public: + WriteBooleanSensorConfigurationSensitivityLevel() + : WriteAttribute("sensitivity-level") + { + AddArgument("attr-name", "sensitivity-level"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteBooleanSensorConfigurationSensitivityLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::SensitivityLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") WriteAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRWriteParams alloc] init]; + params.timedWriteTimeout = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil; + NSNumber * _Nonnull value = [NSNumber numberWithUnsignedChar:mValue]; + + [cluster writeAttributeSensitivityLevelWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("BooleanSensorConfiguration SensitivityLevel write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + uint8_t mValue; +}; + +class SubscribeAttributeBooleanSensorConfigurationSensitivityLevel : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationSensitivityLevel() + : SubscribeAttribute("sensitivity-level") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationSensitivityLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::SensitivityLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeSensitivityLevelWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.SensitivityLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AlarmsActive + */ +class ReadBooleanSensorConfigurationAlarmsActive : public ReadAttribute { +public: + ReadBooleanSensorConfigurationAlarmsActive() + : ReadAttribute("alarms-active") + { + } + + ~ReadBooleanSensorConfigurationAlarmsActive() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsActive::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAlarmsActiveWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AlarmsActive response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration AlarmsActive read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationAlarmsActive : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationAlarmsActive() + : SubscribeAttribute("alarms-active") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationAlarmsActive() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsActive::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAlarmsActiveWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AlarmsActive response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AlarmsSuppressed + */ +class ReadBooleanSensorConfigurationAlarmsSuppressed : public ReadAttribute { +public: + ReadBooleanSensorConfigurationAlarmsSuppressed() + : ReadAttribute("alarms-suppressed") + { + } + + ~ReadBooleanSensorConfigurationAlarmsSuppressed() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsSuppressed::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAlarmsSuppressedWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AlarmsSuppressed response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration AlarmsSuppressed read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationAlarmsSuppressed : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationAlarmsSuppressed() + : SubscribeAttribute("alarms-suppressed") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationAlarmsSuppressed() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsSuppressed::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAlarmsSuppressedWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AlarmsSuppressed response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AlarmsEnabled + */ +class ReadBooleanSensorConfigurationAlarmsEnabled : public ReadAttribute { +public: + ReadBooleanSensorConfigurationAlarmsEnabled() + : ReadAttribute("alarms-enabled") + { + } + + ~ReadBooleanSensorConfigurationAlarmsEnabled() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsEnabled::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAlarmsEnabledWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AlarmsEnabled response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration AlarmsEnabled read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteBooleanSensorConfigurationAlarmsEnabled : public WriteAttribute { +public: + WriteBooleanSensorConfigurationAlarmsEnabled() + : WriteAttribute("alarms-enabled") + { + AddArgument("attr-name", "alarms-enabled"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteBooleanSensorConfigurationAlarmsEnabled() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsEnabled::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") WriteAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRWriteParams alloc] init]; + params.timedWriteTimeout = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil; + NSNumber * _Nonnull value = [NSNumber numberWithUnsignedChar:mValue]; + + [cluster writeAttributeAlarmsEnabledWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("BooleanSensorConfiguration AlarmsEnabled write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + uint8_t mValue; +}; + +class SubscribeAttributeBooleanSensorConfigurationAlarmsEnabled : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationAlarmsEnabled() + : SubscribeAttribute("alarms-enabled") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationAlarmsEnabled() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AlarmsEnabled::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAlarmsEnabledWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AlarmsEnabled response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute GeneratedCommandList + */ +class ReadBooleanSensorConfigurationGeneratedCommandList : public ReadAttribute { +public: + ReadBooleanSensorConfigurationGeneratedCommandList() + : ReadAttribute("generated-command-list") + { + } + + ~ReadBooleanSensorConfigurationGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::GeneratedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration GeneratedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationGeneratedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationGeneratedCommandList() + : SubscribeAttribute("generated-command-list") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::GeneratedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeGeneratedCommandListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AcceptedCommandList + */ +class ReadBooleanSensorConfigurationAcceptedCommandList : public ReadAttribute { +public: + ReadBooleanSensorConfigurationAcceptedCommandList() + : ReadAttribute("accepted-command-list") + { + } + + ~ReadBooleanSensorConfigurationAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AcceptedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration AcceptedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationAcceptedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationAcceptedCommandList() + : SubscribeAttribute("accepted-command-list") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AcceptedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAcceptedCommandListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute EventList + */ +class ReadBooleanSensorConfigurationEventList : public ReadAttribute { +public: + ReadBooleanSensorConfigurationEventList() + : ReadAttribute("event-list") + { + } + + ~ReadBooleanSensorConfigurationEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::EventList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration EventList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationEventList : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationEventList() + : SubscribeAttribute("event-list") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::EventList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeEventListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AttributeList + */ +class ReadBooleanSensorConfigurationAttributeList : public ReadAttribute { +public: + ReadBooleanSensorConfigurationAttributeList() + : ReadAttribute("attribute-list") + { + } + + ~ReadBooleanSensorConfigurationAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AttributeList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration AttributeList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationAttributeList : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationAttributeList() + : SubscribeAttribute("attribute-list") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::AttributeList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAttributeListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute FeatureMap + */ +class ReadBooleanSensorConfigurationFeatureMap : public ReadAttribute { +public: + ReadBooleanSensorConfigurationFeatureMap() + : ReadAttribute("feature-map") + { + } + + ~ReadBooleanSensorConfigurationFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::FeatureMap::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration FeatureMap read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationFeatureMap : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationFeatureMap() + : SubscribeAttribute("feature-map") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::FeatureMap::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeFeatureMapWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ClusterRevision + */ +class ReadBooleanSensorConfigurationClusterRevision : public ReadAttribute { +public: + ReadBooleanSensorConfigurationClusterRevision() + : ReadAttribute("cluster-revision") + { + } + + ~ReadBooleanSensorConfigurationClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::ClusterRevision::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("BooleanSensorConfiguration ClusterRevision read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeBooleanSensorConfigurationClusterRevision : public SubscribeAttribute { +public: + SubscribeAttributeBooleanSensorConfigurationClusterRevision() + : SubscribeAttribute("cluster-revision") + { + } + + ~SubscribeAttributeBooleanSensorConfigurationClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::BooleanSensorConfiguration::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::BooleanSensorConfiguration::Attributes::ClusterRevision::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterBooleanSensorConfiguration alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeClusterRevisionWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"BooleanSensorConfiguration.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/*----------------------------------------------------------------------------*\ +| Cluster ValveConfigurationAndControl | 0x0081 | +|------------------------------------------------------------------------------| +| Commands: | | +| * Open | 0x00 | +| * Close | 0x01 | +| * SetLevel | 0x02 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * OpenDuration | 0x0000 | +| * AutoCloseTime | 0x0001 | +| * RemainingDuration | 0x0002 | +| * CurrentState | 0x0003 | +| * TargetState | 0x0004 | +| * StartUpState | 0x0005 | +| * CurrentLevel | 0x0006 | +| * TargetLevel | 0x0007 | +| * OpenLevel | 0x0008 | +| * ValveFault | 0x0009 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +| * ValveStateChanged | 0x0000 | +| * ValveFault | 0x0001 | +\*----------------------------------------------------------------------------*/ + +#if MTR_ENABLE_PROVISIONAL +/* + * Command Open + */ +class ValveConfigurationAndControlOpen : public ClusterCommand { +public: + ValveConfigurationAndControlOpen() + : ClusterCommand("open") + { +#if MTR_ENABLE_PROVISIONAL + AddArgument("OpenDuration", 0, UINT32_MAX, &mRequest.openDuration); +#endif // MTR_ENABLE_PROVISIONAL + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRValveConfigurationAndControlClusterOpenParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; +#if MTR_ENABLE_PROVISIONAL + if (mRequest.openDuration.HasValue()) { + params.openDuration = [NSNumber numberWithUnsignedInt:mRequest.openDuration.Value()]; + } else { + params.openDuration = nil; + } +#endif // MTR_ENABLE_PROVISIONAL + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster openWithParams:params completion: + ^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(commandId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::ValveConfigurationAndControl::Commands::Open::Type mRequest; +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/* + * Command Close + */ +class ValveConfigurationAndControlClose : public ClusterCommand { +public: + ValveConfigurationAndControlClose() + : ClusterCommand("close") + { + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::Close::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRValveConfigurationAndControlClusterCloseParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster closeWithParams:params completion: + ^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(commandId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/* + * Command SetLevel + */ +class ValveConfigurationAndControlSetLevel : public ClusterCommand { +public: + ValveConfigurationAndControlSetLevel() + : ClusterCommand("set-level") + { +#if MTR_ENABLE_PROVISIONAL + AddArgument("Level", 0, UINT8_MAX, &mRequest.level); +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + AddArgument("OpenDuration", 0, UINT32_MAX, &mRequest.openDuration); +#endif // MTR_ENABLE_PROVISIONAL + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId commandId = chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") command (0x%08" PRIX32 ") on endpoint %u", clusterId, commandId, endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRValveConfigurationAndControlClusterSetLevelParams alloc] init]; + params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; +#if MTR_ENABLE_PROVISIONAL + params.level = [NSNumber numberWithUnsignedChar:mRequest.level]; +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + if (mRequest.openDuration.HasValue()) { + params.openDuration = [NSNumber numberWithUnsignedInt:mRequest.openDuration.Value()]; + } else { + params.openDuration = nil; + } +#endif // MTR_ENABLE_PROVISIONAL + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster setLevelWithParams:params completion: + ^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + RemoteDataModelLogger::LogCommandErrorAsJSON(@(endpointId), @(clusterId), @(commandId), error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::ValveConfigurationAndControl::Commands::SetLevel::Type mRequest; +}; + +#endif // MTR_ENABLE_PROVISIONAL + +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute OpenDuration + */ +class ReadValveConfigurationAndControlOpenDuration : public ReadAttribute { +public: + ReadValveConfigurationAndControlOpenDuration() + : ReadAttribute("open-duration") + { + } + + ~ReadValveConfigurationAndControlOpenDuration() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenDuration::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeOpenDurationWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.OpenDuration response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl OpenDuration read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteValveConfigurationAndControlOpenDuration : public WriteAttribute { +public: + WriteValveConfigurationAndControlOpenDuration() + : WriteAttribute("open-duration") + { + AddArgument("attr-name", "open-duration"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteValveConfigurationAndControlOpenDuration() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenDuration::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") WriteAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRWriteParams alloc] init]; + params.timedWriteTimeout = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil; + NSNumber * _Nullable value = nil; + if (!mValue.IsNull()) { + value = [NSNumber numberWithUnsignedInt:mValue.Value()]; + } + + [cluster writeAttributeOpenDurationWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("ValveConfigurationAndControl OpenDuration write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + chip::app::DataModel::Nullable mValue; +}; + +class SubscribeAttributeValveConfigurationAndControlOpenDuration : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlOpenDuration() + : SubscribeAttribute("open-duration") + { + } + + ~SubscribeAttributeValveConfigurationAndControlOpenDuration() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenDuration::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeOpenDurationWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.OpenDuration response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AutoCloseTime + */ +class ReadValveConfigurationAndControlAutoCloseTime : public ReadAttribute { +public: + ReadValveConfigurationAndControlAutoCloseTime() + : ReadAttribute("auto-close-time") + { + } + + ~ReadValveConfigurationAndControlAutoCloseTime() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::AutoCloseTime::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAutoCloseTimeWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.AutoCloseTime response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl AutoCloseTime read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlAutoCloseTime : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlAutoCloseTime() + : SubscribeAttribute("auto-close-time") + { + } + + ~SubscribeAttributeValveConfigurationAndControlAutoCloseTime() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::AutoCloseTime::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAutoCloseTimeWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.AutoCloseTime response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute RemainingDuration + */ +class ReadValveConfigurationAndControlRemainingDuration : public ReadAttribute { +public: + ReadValveConfigurationAndControlRemainingDuration() + : ReadAttribute("remaining-duration") + { + } + + ~ReadValveConfigurationAndControlRemainingDuration() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::RemainingDuration::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeRemainingDurationWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.RemainingDuration response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl RemainingDuration read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlRemainingDuration : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlRemainingDuration() + : SubscribeAttribute("remaining-duration") + { + } + + ~SubscribeAttributeValveConfigurationAndControlRemainingDuration() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::RemainingDuration::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeRemainingDurationWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.RemainingDuration response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute CurrentState + */ +class ReadValveConfigurationAndControlCurrentState : public ReadAttribute { +public: + ReadValveConfigurationAndControlCurrentState() + : ReadAttribute("current-state") + { + } + + ~ReadValveConfigurationAndControlCurrentState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::CurrentState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeCurrentStateWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.CurrentState response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl CurrentState read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlCurrentState : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlCurrentState() + : SubscribeAttribute("current-state") + { + } + + ~SubscribeAttributeValveConfigurationAndControlCurrentState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::CurrentState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeCurrentStateWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.CurrentState response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute TargetState + */ +class ReadValveConfigurationAndControlTargetState : public ReadAttribute { +public: + ReadValveConfigurationAndControlTargetState() + : ReadAttribute("target-state") + { + } + + ~ReadValveConfigurationAndControlTargetState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::TargetState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeTargetStateWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.TargetState response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl TargetState read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlTargetState : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlTargetState() + : SubscribeAttribute("target-state") + { + } + + ~SubscribeAttributeValveConfigurationAndControlTargetState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::TargetState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeTargetStateWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.TargetState response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute StartUpState + */ +class ReadValveConfigurationAndControlStartUpState : public ReadAttribute { +public: + ReadValveConfigurationAndControlStartUpState() + : ReadAttribute("start-up-state") + { + } + + ~ReadValveConfigurationAndControlStartUpState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::StartUpState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeStartUpStateWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.StartUpState response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl StartUpState read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteValveConfigurationAndControlStartUpState : public WriteAttribute { +public: + WriteValveConfigurationAndControlStartUpState() + : WriteAttribute("start-up-state") + { + AddArgument("attr-name", "start-up-state"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteValveConfigurationAndControlStartUpState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::StartUpState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") WriteAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRWriteParams alloc] init]; + params.timedWriteTimeout = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil; + NSNumber * _Nonnull value = [NSNumber numberWithUnsignedChar:mValue]; + + [cluster writeAttributeStartUpStateWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("ValveConfigurationAndControl StartUpState write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + uint8_t mValue; +}; + +class SubscribeAttributeValveConfigurationAndControlStartUpState : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlStartUpState() + : SubscribeAttribute("start-up-state") + { + } + + ~SubscribeAttributeValveConfigurationAndControlStartUpState() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::StartUpState::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeStartUpStateWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.StartUpState response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute CurrentLevel + */ +class ReadValveConfigurationAndControlCurrentLevel : public ReadAttribute { +public: + ReadValveConfigurationAndControlCurrentLevel() + : ReadAttribute("current-level") + { + } + + ~ReadValveConfigurationAndControlCurrentLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::CurrentLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeCurrentLevelWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.CurrentLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl CurrentLevel read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlCurrentLevel : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlCurrentLevel() + : SubscribeAttribute("current-level") + { + } + + ~SubscribeAttributeValveConfigurationAndControlCurrentLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::CurrentLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeCurrentLevelWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.CurrentLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute TargetLevel + */ +class ReadValveConfigurationAndControlTargetLevel : public ReadAttribute { +public: + ReadValveConfigurationAndControlTargetLevel() + : ReadAttribute("target-level") + { + } + + ~ReadValveConfigurationAndControlTargetLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::TargetLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeTargetLevelWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.TargetLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl TargetLevel read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlTargetLevel : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlTargetLevel() + : SubscribeAttribute("target-level") + { + } + + ~SubscribeAttributeValveConfigurationAndControlTargetLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::TargetLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeTargetLevelWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.TargetLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute OpenLevel + */ +class ReadValveConfigurationAndControlOpenLevel : public ReadAttribute { +public: + ReadValveConfigurationAndControlOpenLevel() + : ReadAttribute("open-level") + { + } + + ~ReadValveConfigurationAndControlOpenLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeOpenLevelWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.OpenLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl OpenLevel read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteValveConfigurationAndControlOpenLevel : public WriteAttribute { +public: + WriteValveConfigurationAndControlOpenLevel() + : WriteAttribute("open-level") + { + AddArgument("attr-name", "open-level"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteValveConfigurationAndControlOpenLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") WriteAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRWriteParams alloc] init]; + params.timedWriteTimeout = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil; + NSNumber * _Nullable value = nil; + if (!mValue.IsNull()) { + value = [NSNumber numberWithUnsignedChar:mValue.Value()]; + } + + [cluster writeAttributeOpenLevelWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("ValveConfigurationAndControl OpenLevel write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + chip::app::DataModel::Nullable mValue; +}; + +class SubscribeAttributeValveConfigurationAndControlOpenLevel : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlOpenLevel() + : SubscribeAttribute("open-level") + { + } + + ~SubscribeAttributeValveConfigurationAndControlOpenLevel() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::OpenLevel::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeOpenLevelWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.OpenLevel response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ValveFault + */ +class ReadValveConfigurationAndControlValveFault : public ReadAttribute { +public: + ReadValveConfigurationAndControlValveFault() + : ReadAttribute("valve-fault") + { + } + + ~ReadValveConfigurationAndControlValveFault() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::ValveFault::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeValveFaultWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.ValveFault response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl ValveFault read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlValveFault : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlValveFault() + : SubscribeAttribute("valve-fault") + { + } + + ~SubscribeAttributeValveConfigurationAndControlValveFault() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::ValveFault::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeValveFaultWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.ValveFault response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute GeneratedCommandList + */ +class ReadValveConfigurationAndControlGeneratedCommandList : public ReadAttribute { +public: + ReadValveConfigurationAndControlGeneratedCommandList() + : ReadAttribute("generated-command-list") + { + } + + ~ReadValveConfigurationAndControlGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::GeneratedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl GeneratedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlGeneratedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlGeneratedCommandList() + : SubscribeAttribute("generated-command-list") + { + } + + ~SubscribeAttributeValveConfigurationAndControlGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::GeneratedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeGeneratedCommandListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AcceptedCommandList + */ +class ReadValveConfigurationAndControlAcceptedCommandList : public ReadAttribute { +public: + ReadValveConfigurationAndControlAcceptedCommandList() + : ReadAttribute("accepted-command-list") + { + } + + ~ReadValveConfigurationAndControlAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::AcceptedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl AcceptedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlAcceptedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlAcceptedCommandList() + : SubscribeAttribute("accepted-command-list") + { + } + + ~SubscribeAttributeValveConfigurationAndControlAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::AcceptedCommandList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAcceptedCommandListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute EventList + */ +class ReadValveConfigurationAndControlEventList : public ReadAttribute { +public: + ReadValveConfigurationAndControlEventList() + : ReadAttribute("event-list") + { + } + + ~ReadValveConfigurationAndControlEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::EventList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl EventList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlEventList : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlEventList() + : SubscribeAttribute("event-list") + { + } + + ~SubscribeAttributeValveConfigurationAndControlEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::EventList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeEventListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute AttributeList + */ +class ReadValveConfigurationAndControlAttributeList : public ReadAttribute { +public: + ReadValveConfigurationAndControlAttributeList() + : ReadAttribute("attribute-list") + { + } + + ~ReadValveConfigurationAndControlAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::AttributeList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl AttributeList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlAttributeList : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlAttributeList() + : SubscribeAttribute("attribute-list") + { + } + + ~SubscribeAttributeValveConfigurationAndControlAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::AttributeList::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAttributeListWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute FeatureMap + */ +class ReadValveConfigurationAndControlFeatureMap : public ReadAttribute { +public: + ReadValveConfigurationAndControlFeatureMap() + : ReadAttribute("feature-map") + { + } + + ~ReadValveConfigurationAndControlFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::FeatureMap::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl FeatureMap read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlFeatureMap : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlFeatureMap() + : SubscribeAttribute("feature-map") + { + } + + ~SubscribeAttributeValveConfigurationAndControlFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::FeatureMap::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeFeatureMapWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute ClusterRevision + */ +class ReadValveConfigurationAndControlClusterRevision : public ReadAttribute { +public: + ReadValveConfigurationAndControlClusterRevision() + : ReadAttribute("cluster-revision") + { + } + + ~ReadValveConfigurationAndControlClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::ClusterRevision::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReadAttribute (0x%08" PRIX32 ") on endpoint %u", endpointId, clusterId, attributeId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("ValveConfigurationAndControl ClusterRevision read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeValveConfigurationAndControlClusterRevision : public SubscribeAttribute { +public: + SubscribeAttributeValveConfigurationAndControlClusterRevision() + : SubscribeAttribute("cluster-revision") + { + } + + ~SubscribeAttributeValveConfigurationAndControlClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::ValveConfigurationAndControl::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::ValveConfigurationAndControl::Attributes::ClusterRevision::Id; + + ChipLogProgress(chipTool, "Sending cluster (0x%08" PRIX32 ") ReportAttribute (0x%08" PRIX32 ") on endpoint %u", clusterId, attributeId, endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterValveConfigurationAndControl alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeClusterRevisionWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"ValveConfigurationAndControl.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + #endif // MTR_ENABLE_PROVISIONAL #endif // MTR_ENABLE_PROVISIONAL #if MTR_ENABLE_PROVISIONAL @@ -161353,6 +164055,165 @@ void registerClusterActivatedCarbonFilterMonitoring(Commands & commands) commands.RegisterCluster(clusterName, clusterCommands); #endif // MTR_ENABLE_PROVISIONAL } +void registerClusterBooleanSensorConfiguration(Commands & commands) +{ +#if MTR_ENABLE_PROVISIONAL + using namespace chip::app::Clusters::BooleanSensorConfiguration; + + const char * clusterName = "BooleanSensorConfiguration"; + + commands_list clusterCommands = { + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL + make_unique(Id), // + make_unique(Id), // + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL + make_unique(Id), // + make_unique(Id), // + }; + + commands.RegisterCluster(clusterName, clusterCommands); +#endif // MTR_ENABLE_PROVISIONAL +} +void registerClusterValveConfigurationAndControl(Commands & commands) +{ +#if MTR_ENABLE_PROVISIONAL + using namespace chip::app::Clusters::ValveConfigurationAndControl; + + const char * clusterName = "ValveConfigurationAndControl"; + + commands_list clusterCommands = { + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL + make_unique(Id), // + make_unique(Id), // + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL + make_unique(Id), // + make_unique(Id), // + }; + + commands.RegisterCluster(clusterName, clusterCommands); +#endif // MTR_ENABLE_PROVISIONAL +} void registerClusterDemandResponseLoadControl(Commands & commands) { #if MTR_ENABLE_PROVISIONAL @@ -164576,6 +167437,8 @@ void registerClusters(Commands & commands) registerClusterRvcOperationalState(commands); registerClusterHepaFilterMonitoring(commands); registerClusterActivatedCarbonFilterMonitoring(commands); + registerClusterBooleanSensorConfiguration(commands); + registerClusterValveConfigurationAndControl(commands); registerClusterDemandResponseLoadControl(commands); registerClusterDoorLock(commands); registerClusterWindowCovering(commands);