From 7e68a718df5abf5b2a161e72d7cc831465fe08e8 Mon Sep 17 00:00:00 2001 From: abeck-riis <98488327+abeck-riis@users.noreply.github.com> Date: Mon, 6 Nov 2023 23:40:52 -0600 Subject: [PATCH 01/26] Initial OpState work Adding oven op state Python regen Fixing alignment regenerate with oven device. regenerated zap and chiptool oven opState first pass builds and runs, but running tests results in a lot of failure messages. tentative updates based on RVC updated cluster name & fix build linux builds with oven mode update. remove duplicate ovencacvity Entries remove duplicate oven cavity entry Revert "remove duplicate ovencacvity Entries" This reverts commit 87e891ebcf342f6cb70e17c36e36c8370c2b9983. oven mode is responding appropriately cleanup for ovenMode regenerate zap Removing OvenMode related changes regen zap --- .vscode/settings.json | 2 +- .../include/oven-operational-state-delegate.h | 141 +++ .../src/oven-operational-state-delegate.cpp | 89 ++ .../esp32/main/CMakeLists.txt | 259 ++-- examples/all-clusters-app/linux/BUILD.gn | 1 + .../all-clusters-app/linux/main-common.cpp | 2 + .../operational-state-oven-cluster-objects.h | 271 ++++ .../operational-state-oven-server.cpp | 411 ++++++ .../operational-state-oven-server.h | 280 +++++ src/app/common/templates/config-data.yaml | 1 + src/app/util/util.cpp | 1 + .../data_model/controller-clusters.zap | 261 +--- .../chip/devicecontroller/ChipClusters.java | 347 ------ .../devicecontroller/ChipEventStructs.java | 924 -------------- .../chip/devicecontroller/ChipStructs.java | 61 - .../devicecontroller/ClusterIDMapping.java | 108 -- .../devicecontroller/ClusterInfoMapping.java | 156 --- .../devicecontroller/ClusterReadMapping.java | 126 -- .../devicecontroller/ClusterWriteMapping.java | 46 - ...nalStateClusterOperationCompletionEvent.kt | 106 ++ ...tionalStateClusterOperationalErrorEvent.kt | 61 + .../chip/devicecontroller/cluster/files.gni | 1 - ...OperationalStateClusterErrorStateStruct.kt | 85 ++ ...ionalStateClusterOperationalStateStruct.kt | 74 ++ ...nalStateClusterOperationCompletionEvent.kt | 106 ++ ...tionalStateClusterOperationalErrorEvent.kt | 62 + ...OperationalStateClusterErrorStateStruct.kt | 85 ++ ...ionalStateClusterOperationalStateStruct.kt | 74 ++ .../clusters/OvenOperationalStateCluster.kt | 211 ++++ .../matter/devicecontroller/cluster/files.gni | 252 ++++ .../CHIPEventTLVValueDecoder.cpp | 10 - .../python/chip/clusters/CHIPClusters.py | 78 -- .../python/chip/clusters/Objects.py | 242 ---- .../python/chip/clusters/__init__.py | 11 + .../MTRAttributeSpecifiedCheck.mm | 45 - .../MTRAttributeTLVValueDecoder.mm | 137 -- .../CHIP/zap-generated/MTRBaseClusters.h | 107 -- .../CHIP/zap-generated/MTRBaseClusters.mm | 456 ------- .../CHIP/zap-generated/MTRClusterConstants.h | 14 - .../CHIP/zap-generated/MTRClusters.h | 50 - .../CHIP/zap-generated/MTRClusters.mm | 81 -- .../zap-generated/MTRCommandTimedCheck.mm | 12 - .../zap-generated/MTREventTLVValueDecoder.mm | 15 - .../CHIP/zap-generated/MTRStructsObjc.h | 6 - .../CHIP/zap-generated/MTRStructsObjc.mm | 30 - third_party/imgui/repo | 2 +- third_party/libwebsockets/repo | 2 +- third_party/mbedtls/repo | 2 +- third_party/nanopb/repo | 2 +- third_party/openthread/repo | 2 +- third_party/ot-br-posix/repo | 2 +- third_party/pigweed/repo | 2 +- .../zap-generated/attributes/Accessors.cpp | 130 -- .../zap-generated/attributes/Accessors.h | 26 - .../zap-generated/cluster-enums-check.h | 15 - .../app-common/zap-generated/cluster-enums.h | 24 - .../zap-generated/cluster-objects.cpp | 83 -- .../zap-generated/cluster-objects.h | 154 --- .../app-common/zap-generated/ids/Attributes.h | 50 - .../app-common/zap-generated/ids/Clusters.h | 3 - .../app-common/zap-generated/print-cluster.h | 7 - .../zap-generated/cluster/Commands.h | 103 -- .../cluster/logging/DataModelLogger.cpp | 86 -- .../zap-generated/cluster/Commands.h | 1105 ----------------- 64 files changed, 2483 insertions(+), 5215 deletions(-) create mode 100644 examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h create mode 100644 examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp create mode 100644 src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h create mode 100644 src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp create mode 100644 src/app/clusters/operational-state-oven-server/operational-state-oven-server.h create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt create mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt create mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt create mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni diff --git a/.vscode/settings.json b/.vscode/settings.json index bfac435030bb4f..905aa90a8427e7 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -127,7 +127,7 @@ "**/third_party/**": true }, "files.eol": "\n", - "editor.formatOnSave": true, + "editor.formatOnSave": false, "better-comments.tags": [ { "tag": "!", diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h new file mode 100644 index 00000000000000..aa33602816e485 --- /dev/null +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -0,0 +1,141 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { + +// class RvcDevice; + +// typedef void (RvcDevice::*HandleOpStateCommand)(Clusters::OperationalState::GenericOperationalError & err); + +namespace OvenCavityOperationalState { + +// This is an application level delegate to handle operational state commands according to the specific business logic. +class OvenCavityOperationalStateDelegate : public OperationalState::Delegate +{ +private: + const Clusters::OperationalState::GenericOperationalState mOperationalStateList[8] = { + OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kStopped)), + OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kRunning)), + OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kPaused)), + OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kError)), + // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kPreheating)), + // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kPreheated)), + // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kCoolingDown)), + // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kSelfCleaning)) + }; + + const Clusters::OperationalState::GenericOperationalPhase mOperationalPhaseList[1] = { + // Phase List is null + OperationalState::GenericOperationalPhase(DataModel::Nullable()), + }; + + //RvcDevice * mPauseRvcDeviceInstance; + //HandleOpStateCommand mPauseCallback; + //RvcDevice * mResumeRvcDeviceInstance; + //HandleOpStateCommand mResumeCallback; + +public: + /** + * Get the countdown time. This attribute is not supported in our example RVC app. + * @return Null. + */ + DataModel::Nullable GetCountdownTime() override { return {}; }; + + /** + * Fills in the provided GenericOperationalState with the state at index `index` if there is one, + * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of states. + * Note: This is used by the SDK to populate the operational state list attribute. If the contents of this list changes, + * the device SHALL call the Instance's ReportOperationalStateListChange method to report that this attribute has changed. + * @param index The index of the state, with 0 representing the first state. + * @param operationalState The GenericOperationalState is filled. + */ + CHIP_ERROR GetOperationalStateAtIndex(size_t index, + Clusters::OperationalState::GenericOperationalState & operationalState) override; + + /** + * Fills in the provided GenericOperationalPhase with the phase at index `index` if there is one, + * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of phases. + * Note: This is used by the SDK to populate the phase list attribute. If the contents of this list changes, the + * device SHALL call the Instance's ReportPhaseListChange method to report that this attribute has changed. + * @param index The index of the phase, with 0 representing the first phase. + * @param operationalPhase The GenericOperationalPhase is filled. + */ + CHIP_ERROR GetOperationalPhaseAtIndex(size_t index, + Clusters::OperationalState::GenericOperationalPhase & operationalPhase) override; + + // command callback + /** + * Handle Command Callback in application: Pause + * @param[out] get operational error after callback. + */ + void HandlePauseStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + // This command in not supported. + }; + + /** + * Handle Command Callback in application: Resume + * @param[out] get operational error after callback. + */ + void HandleResumeStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + // This command in not supported. + }; + + /** + * Handle Command Callback in application: Start + * @param[out] get operational error after callback. + */ + void HandleStartStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + // This command in not supported. + }; + + /** + * Handle Command Callback in application: Stop + * @param[out] get operational error after callback. + */ + void HandleStopStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + // This command in not supported. + }; + + // void SetPauseCallback(HandleOpStateCommand aCallback, RvcDevice * aInstance) + // { + // mPauseCallback = aCallback; + // mPauseRvcDeviceInstance = aInstance; + // }; + + // void SetResumeCallback(HandleOpStateCommand aCallback, RvcDevice * aInstance) + // { + // mResumeCallback = aCallback; + // mResumeRvcDeviceInstance = aInstance; + // }; +}; + +void Shutdown(); + +} // namespace OvenCavityOperationalState +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp new file mode 100644 index 00000000000000..9c5e0d10e64cf0 --- /dev/null +++ b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp @@ -0,0 +1,89 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include + +using namespace chip; +using namespace chip::app; +using namespace chip::app::Clusters; +using namespace chip::app::Clusters::OvenCavityOperationalState; + +static OperationalState::Instance * gOvenCavityOperationalStateInstance = nullptr; +static OvenCavityOperationalStateDelegate * gOvenCavityOperationalStateDelegate = nullptr; + +void OvenCavityOperationalState::Shutdown() +{ + if (gOvenCavityOperationalStateInstance != nullptr) + { + delete gOvenCavityOperationalStateInstance; + gOvenCavityOperationalStateInstance = nullptr; + } + if (gOvenCavityOperationalStateDelegate != nullptr) + { + delete gOvenCavityOperationalStateDelegate; + gOvenCavityOperationalStateDelegate = nullptr; + } +} + +void emberAfOvenCavityOperationalStateClusterInitCallback(chip::EndpointId endpointId) +{ + VerifyOrDie(endpointId == 1); // this cluster is only enabled for endpoint 1. + VerifyOrDie(gOvenCavityOperationalStateInstance == nullptr && gOvenCavityOperationalStateDelegate == nullptr); + + gOvenCavityOperationalStateDelegate = new OvenCavityOperationalStateDelegate; + EndpointId operationalStateEndpoint = 0x01; + gOvenCavityOperationalStateInstance = new OvenCavityOperationalState::Instance(gOvenCavityOperationalStateDelegate, operationalStateEndpoint); + + gOvenCavityOperationalStateInstance->SetOperationalState(to_underlying(OperationalState::OperationalStateEnum::kStopped)); + + gOvenCavityOperationalStateInstance->Init(); +} + + +CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalStateAtIndex(size_t index, + OperationalState::GenericOperationalState & operationalState) +{ + if (index >= ArraySize(mOperationalStateList)) + { + return CHIP_ERROR_NOT_FOUND; + } + operationalState = mOperationalStateList[index]; + return CHIP_NO_ERROR; +} + +CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, + OperationalState::GenericOperationalPhase & operationalPhase) +{ + if (index >= ArraySize(mOperationalPhaseList)) + { + return CHIP_ERROR_NOT_FOUND; + } + operationalPhase = mOperationalPhaseList[index]; + return CHIP_NO_ERROR; +} + + + +// void RvcOperationalStateDelegate::HandlePauseStateCallback(OperationalState::GenericOperationalError & err) +// { +// (mPauseRvcDeviceInstance->*mPauseCallback)(err); +// } + +// void RvcOperationalStateDelegate::HandleResumeStateCallback(OperationalState::GenericOperationalError & err) +// { +// (mResumeRvcDeviceInstance->*mResumeCallback)(err); +// } diff --git a/examples/all-clusters-app/esp32/main/CMakeLists.txt b/examples/all-clusters-app/esp32/main/CMakeLists.txt index 623e2ded547abe..3ee8c1e6e243a7 100644 --- a/examples/all-clusters-app/esp32/main/CMakeLists.txt +++ b/examples/all-clusters-app/esp32/main/CMakeLists.txt @@ -1,28 +1,28 @@ # -# Copyright (c) 2021 Project CHIP Authors -# All rights reserved. +# Copyright (c) 2021 Project CHIP Authors +# All rights reserved. # -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at +# 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 +# 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. +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. # # (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) # The list of src and include dirs must be in sync with that in all-clusters-app/esp32/main/component.mk set(PRIV_INCLUDE_DIRS_LIST - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/include" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/energy-management-app/energy-management-common/include" - "${CMAKE_CURRENT_LIST_DIR}/include" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/providers" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/third_party/nlfaultinjection/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/energy-management-app/energy-management-common/include" + "${CMAKE_CURRENT_LIST_DIR}/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/providers" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/third_party/nlfaultinjection/include" ) set(SRC_DIRS_LIST "${CMAKE_CURRENT_LIST_DIR}" @@ -92,55 +92,55 @@ set(SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/dishwasher-alarm-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/laundry-washer-controls-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/laundry-dryer-controls-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/operational-state-oven-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/src" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/electrical-energy-measurement-server" ) - set(EXCLUDE_SRCS "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp") -if (CONFIG_ENABLE_PW_RPC) -# Append additional directories for RPC build -set(PRIV_INCLUDE_DIRS_LIST "${PRIV_INCLUDE_DIRS_LIST}" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/pw_sys_io/public" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/lib/support" -) +if(CONFIG_ENABLE_PW_RPC) + # Append additional directories for RPC build + set(PRIV_INCLUDE_DIRS_LIST "${PRIV_INCLUDE_DIRS_LIST}" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/pw_sys_io/public" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/lib/support" + ) -if (${IDF_VERSION_MAJOR} LESS 5) + if(${IDF_VERSION_MAJOR} LESS 5) list(APPEND PRIV_INCLUDE_DIRS_LIST "${IDF_PATH}/components/freertos/include/freertos") -else() + else() list(APPEND PRIV_INCLUDE_DIRS_LIST "${IDF_PATH}/components/freertos/FreeRTOS-Kernel/include/freertos") -endif() + endif() -set(SRC_DIRS_LIST "${SRC_DIRS_LIST}" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" -) -endif (CONFIG_ENABLE_PW_RPC) + set(SRC_DIRS_LIST "${SRC_DIRS_LIST}" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" + ) +endif(CONFIG_ENABLE_PW_RPC) -if (CONFIG_ENABLE_ICD_SERVER) - list(APPEND PRIV_INCLUDE_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") - list(APPEND SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") +if(CONFIG_ENABLE_ICD_SERVER) + list(APPEND PRIV_INCLUDE_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") + list(APPEND SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") endif() set(PRIV_REQUIRES_LIST chip QRCode bt app_update nvs_flash spi_flash openthread) if(${IDF_TARGET} STREQUAL "esp32") - list(APPEND PRIV_REQUIRES_LIST spidriver screen-framework) + list(APPEND PRIV_REQUIRES_LIST spidriver screen-framework) endif() if(CONFIG_DEVICE_TYPE_ESP32_C3_DEVKITM) - list(APPEND PRIV_REQUIRES_LIST led_strip) + list(APPEND PRIV_REQUIRES_LIST led_strip) endif() idf_component_register(PRIV_INCLUDE_DIRS ${PRIV_INCLUDE_DIRS_LIST} - SRC_DIRS ${SRC_DIRS_LIST} - EXCLUDE_SRCS ${EXCLUDE_SRCS} - PRIV_REQUIRES ${PRIV_REQUIRES_LIST}) + SRC_DIRS ${SRC_DIRS_LIST} + EXCLUDE_SRCS ${EXCLUDE_SRCS} + PRIV_REQUIRES ${PRIV_REQUIRES_LIST}) get_filename_component(CHIP_ROOT ${CMAKE_SOURCE_DIR}/third_party/connectedhomeip REALPATH) @@ -152,135 +152,132 @@ chip_app_component_zapgen("${CHIP_ROOT}/examples/all-clusters-app/all-clusters-c set_property(TARGET ${COMPONENT_LIB} PROPERTY CXX_STANDARD 17) target_compile_options(${COMPONENT_LIB} PRIVATE "-DCHIP_HAVE_CONFIG_H") target_compile_options(${COMPONENT_LIB} PUBLIC - "-DCHIP_ADDRESS_RESOLVE_IMPL_INCLUDE_HEADER=" + "-DCHIP_ADDRESS_RESOLVE_IMPL_INCLUDE_HEADER=" ) -if (CONFIG_ENABLE_PW_RPC) +if(CONFIG_ENABLE_PW_RPC) + set(PIGWEED_ROOT "${CHIP_ROOT}/third_party/pigweed/repo") + include(${PIGWEED_ROOT}/pw_build/pigweed.cmake) + include(${PIGWEED_ROOT}/pw_protobuf_compiler/proto.cmake) + set(dir_pw_third_party_nanopb "${CHIP_ROOT}/third_party/nanopb/repo" CACHE STRING "" FORCE) - -set(PIGWEED_ROOT "${CHIP_ROOT}/third_party/pigweed/repo") -include(${PIGWEED_ROOT}/pw_build/pigweed.cmake) -include(${PIGWEED_ROOT}/pw_protobuf_compiler/proto.cmake) -set(dir_pw_third_party_nanopb "${CHIP_ROOT}/third_party/nanopb/repo" CACHE STRING "" FORCE) - -pw_proto_library(attributes_service - SOURCES + pw_proto_library(attributes_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/attributes_service.proto - INPUTS + INPUTS ${CHIP_ROOT}/examples/common/pigweed/protos/attributes_service.options - PREFIX + PREFIX attributes_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto -) + ) -pw_proto_library(button_service - SOURCES + pw_proto_library(button_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/button_service.proto - PREFIX + PREFIX button_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto -) + ) -pw_proto_library(descriptor_service - SOURCES + pw_proto_library(descriptor_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/descriptor_service.proto - PREFIX + PREFIX descriptor_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto -) + ) -pw_proto_library(device_service - SOURCES + pw_proto_library(device_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/device_service.proto - INPUTS + INPUTS ${CHIP_ROOT}/examples/common/pigweed/protos/device_service.options - PREFIX + PREFIX device_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto -) + ) -pw_proto_library(lighting_service - SOURCES + pw_proto_library(lighting_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/lighting_service.proto - PREFIX + PREFIX lighting_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto -) + ) -pw_proto_library(locking_service - SOURCES + pw_proto_library(locking_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/locking_service.proto - PREFIX + PREFIX locking_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto -) + ) -pw_proto_library(wifi_service - SOURCES + pw_proto_library(wifi_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/wifi_service.proto - INPUTS + INPUTS ${CHIP_ROOT}/examples/common/pigweed/protos/wifi_service.options - PREFIX + PREFIX wifi_service - DEPS + DEPS pw_protobuf.common_proto - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos -) + ) -target_link_libraries(${COMPONENT_LIB} PUBLIC - attributes_service.nanopb_rpc - button_service.nanopb_rpc - descriptor_service.nanopb_rpc - device_service.nanopb_rpc - lighting_service.nanopb_rpc - locking_service.nanopb_rpc - wifi_service.nanopb_rpc - pw_checksum - pw_hdlc - pw_log - pw_rpc.server - pw_sys_io - pw_trace - pw_trace_tokenized - pw_trace_tokenized.trace_buffer - pw_trace_tokenized.rpc_service - pw_trace_tokenized.protos.nanopb_rpc -) + target_link_libraries(${COMPONENT_LIB} PUBLIC + attributes_service.nanopb_rpc + button_service.nanopb_rpc + descriptor_service.nanopb_rpc + device_service.nanopb_rpc + lighting_service.nanopb_rpc + locking_service.nanopb_rpc + wifi_service.nanopb_rpc + pw_checksum + pw_hdlc + pw_log + pw_rpc.server + pw_sys_io + pw_trace + pw_trace_tokenized + pw_trace_tokenized.trace_buffer + pw_trace_tokenized.rpc_service + pw_trace_tokenized.protos.nanopb_rpc + ) -target_link_options(${COMPONENT_LIB} - PUBLIC + target_link_options(${COMPONENT_LIB} + PUBLIC "-T${PIGWEED_ROOT}/pw_tokenizer/pw_tokenizer_linker_sections.ld" "-L${PIGWEED_ROOT}/pw_tokenizer" -) - -target_compile_options(${COMPONENT_LIB} PRIVATE - "-DPW_RPC_ATTRIBUTE_SERVICE=1" - "-DPW_RPC_BUTTON_SERVICE=1" - "-DPW_RPC_DESCRIPTOR_SERVICE=1" - "-DPW_RPC_DEVICE_SERVICE=1" - "-DPW_RPC_LIGHTING_SERVICE=1" - "-DPW_RPC_LOCKING_SERVICE=1" - "-DPW_RPC_TRACING_SERVICE=1" - "-DPW_RPC_WIFI_SERVICE=1" - "-DPW_TRACE_BACKEND_SET=1") + ) -endif (CONFIG_ENABLE_PW_RPC) + target_compile_options(${COMPONENT_LIB} PRIVATE + "-DPW_RPC_ATTRIBUTE_SERVICE=1" + "-DPW_RPC_BUTTON_SERVICE=1" + "-DPW_RPC_DESCRIPTOR_SERVICE=1" + "-DPW_RPC_DEVICE_SERVICE=1" + "-DPW_RPC_LIGHTING_SERVICE=1" + "-DPW_RPC_LOCKING_SERVICE=1" + "-DPW_RPC_TRACING_SERVICE=1" + "-DPW_RPC_WIFI_SERVICE=1" + "-DPW_TRACE_BACKEND_SET=1") +endif(CONFIG_ENABLE_PW_RPC) diff --git a/examples/all-clusters-app/linux/BUILD.gn b/examples/all-clusters-app/linux/BUILD.gn index 8b031d769773e4..2d9b1090a88f50 100644 --- a/examples/all-clusters-app/linux/BUILD.gn +++ b/examples/all-clusters-app/linux/BUILD.gn @@ -37,6 +37,7 @@ source_set("chip-all-clusters-common") { "${chip_root}/examples/all-clusters-app/all-clusters-common/src/microwave-oven-mode.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/operational-state-delegate-impl.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/oven-modes.cpp", + "${chip_root}/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/resource-monitoring-delegates.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/rvc-modes.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp", diff --git a/examples/all-clusters-app/linux/main-common.cpp b/examples/all-clusters-app/linux/main-common.cpp index 49ee513ca33f95..31c8b728ccd2ac 100644 --- a/examples/all-clusters-app/linux/main-common.cpp +++ b/examples/all-clusters-app/linux/main-common.cpp @@ -28,6 +28,7 @@ #include "microwave-oven-mode.h" #include "operational-state-delegate-impl.h" #include "oven-modes.h" +#include "oven-operational-state-delegate.h" #include "resource-monitoring-delegates.h" #include "rvc-modes.h" #include "tcc-mode.h" @@ -247,6 +248,7 @@ void ApplicationShutdown() Clusters::OperationalState::Shutdown(); Clusters::RvcOperationalState::Shutdown(); Clusters::OvenMode::Shutdown(); + Clusters::OvenCavityOperationalState::Shutdown(); if (sChipNamedPipeCommands.Stop() != CHIP_NO_ERROR) { diff --git a/src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h b/src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h new file mode 100644 index 00000000000000..1910e00d20effb --- /dev/null +++ b/src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h @@ -0,0 +1,271 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { +namespace OperationalState { + +inline constexpr size_t kOperationalStateLabelMaxSize = 64u; +inline constexpr size_t kOperationalErrorLabelMaxSize = 64u; +inline constexpr size_t kOperationalErrorDetailsMaxSize = 64u; +inline constexpr size_t kOperationalPhaseNameMaxSize = 64u; + +/** + * A class which represents the operational state of an Operational State cluster derivation instance. + */ +struct GenericOperationalState : public app::Clusters::detail::Structs::OperationalStateStruct::Type +{ + GenericOperationalState(uint8_t state = to_underlying(OperationalStateEnum::kStopped), Optional label = NullOptional) + { + Set(state, label); + } + + GenericOperationalState(const GenericOperationalState & op) { *this = op; } + + GenericOperationalState & operator=(const GenericOperationalState & op) + { + Set(op.operationalStateID, op.operationalStateLabel); + return *this; + } + + void Set(uint8_t state, Optional label = NullOptional) + { + operationalStateID = state; + if (label.HasValue()) + { + memset(mOperationalStateLabelBuffer, 0, sizeof(mOperationalStateLabelBuffer)); + if (label.Value().size() > sizeof(mOperationalStateLabelBuffer)) + { + memcpy(mOperationalStateLabelBuffer, label.Value().data(), sizeof(mOperationalStateLabelBuffer)); + operationalStateLabel.SetValue(CharSpan(mOperationalStateLabelBuffer, sizeof(mOperationalStateLabelBuffer))); + } + else + { + memcpy(mOperationalStateLabelBuffer, label.Value().data(), label.Value().size()); + operationalStateLabel.SetValue(CharSpan(mOperationalStateLabelBuffer, label.Value().size())); + } + } + else + { + operationalStateLabel = NullOptional; + } + } + +private: + char mOperationalStateLabelBuffer[kOperationalStateLabelMaxSize]; +}; + +/** + * A class which represents the operational error of an Operational State cluster derivation instance. + */ +struct GenericOperationalError : public app::Clusters::detail::Structs::ErrorStateStruct::Type +{ + GenericOperationalError(uint8_t state, Optional label = NullOptional, + Optional details = NullOptional) + { + Set(state, label, details); + } + + GenericOperationalError(const GenericOperationalError & error) { *this = error; } + + GenericOperationalError & operator=(const GenericOperationalError & error) + { + Set(error.errorStateID, error.errorStateLabel, error.errorStateDetails); + return *this; + } + + void Set(uint8_t state, Optional label = NullOptional, Optional details = NullOptional) + { + errorStateID = state; + if (label.HasValue()) + { + memset(mErrorStateLabelBuffer, 0, sizeof(mErrorStateLabelBuffer)); + if (label.Value().size() > sizeof(mErrorStateLabelBuffer)) + { + memcpy(mErrorStateLabelBuffer, label.Value().data(), sizeof(mErrorStateLabelBuffer)); + errorStateLabel.SetValue(CharSpan(mErrorStateLabelBuffer, sizeof(mErrorStateLabelBuffer))); + } + else + { + memcpy(mErrorStateLabelBuffer, label.Value().data(), label.Value().size()); + errorStateLabel.SetValue(CharSpan(mErrorStateLabelBuffer, label.Value().size())); + } + } + else + { + errorStateLabel = NullOptional; + } + + if (details.HasValue()) + { + memset(mErrorStateDetailsBuffer, 0, sizeof(mErrorStateDetailsBuffer)); + if (details.Value().size() > sizeof(mErrorStateDetailsBuffer)) + { + memcpy(mErrorStateDetailsBuffer, details.Value().data(), sizeof(mErrorStateDetailsBuffer)); + errorStateDetails.SetValue(CharSpan(mErrorStateDetailsBuffer, sizeof(mErrorStateDetailsBuffer))); + } + else + { + memcpy(mErrorStateDetailsBuffer, details.Value().data(), details.Value().size()); + errorStateDetails.SetValue(CharSpan(mErrorStateDetailsBuffer, details.Value().size())); + } + } + else + { + errorStateDetails = NullOptional; + } + } + + bool IsEqual(const Structs::ErrorStateStruct::Type & rhs) const + { + if (errorStateID != rhs.errorStateID) + { + return false; + } + if (errorStateLabel.HasValue() != rhs.errorStateLabel.HasValue() || + errorStateDetails.HasValue() != rhs.errorStateDetails.HasValue()) + { + return false; + } + if (errorStateLabel.HasValue()) + { + if (!errorStateLabel.Value().data_equal(rhs.errorStateLabel.Value())) + { + return false; + } + } + if (errorStateDetails.HasValue()) + { + if (!errorStateDetails.Value().data_equal(rhs.errorStateDetails.Value())) + { + return false; + } + } + + return true; + } + +private: + char mErrorStateLabelBuffer[kOperationalErrorLabelMaxSize]; + char mErrorStateDetailsBuffer[kOperationalErrorDetailsMaxSize]; +}; + +/** + * A class which represents the operational phase of an Operational State cluster derivation instance. + */ +struct GenericOperationalPhase +{ + GenericOperationalPhase(app::DataModel::Nullable name) { Set(name); } + + GenericOperationalPhase(const GenericOperationalPhase & ph) { *this = ph; } + + GenericOperationalPhase & operator=(const GenericOperationalPhase & ph) + { + Set(ph.mPhaseName); + return *this; + } + + bool IsMissing() const { return mPhaseName.IsNull(); } + app::DataModel::Nullable mPhaseName; + +private: + void Set(app::DataModel::Nullable name) + { + if (name.IsNull()) + { + mPhaseName.SetNull(); + } + else + { + memset(mPhaseNameBuffer, 0, sizeof(mPhaseNameBuffer)); + if (name.Value().size() > sizeof(mPhaseNameBuffer)) + { + memcpy(mPhaseNameBuffer, name.Value().data(), sizeof(mPhaseNameBuffer)); + mPhaseName = app::DataModel::Nullable(CharSpan(mPhaseNameBuffer, sizeof(mPhaseNameBuffer))); + } + else + { + memcpy(mPhaseNameBuffer, name.Value().data(), name.Value().size()); + mPhaseName = app::DataModel::Nullable(CharSpan(mPhaseNameBuffer, name.Value().size())); + } + } + } + + char mPhaseNameBuffer[kOperationalPhaseNameMaxSize]; +}; + +/** + * A class which represents the operational error event of an Operational State cluster derivation instance. + */ +class GenericErrorEvent : private app::Clusters::OperationalState::Events::OperationalError::Type +{ + using super = app::Clusters::OperationalState::Events::OperationalError::Type; + +public: + GenericErrorEvent(ClusterId aClusterId, const Structs::ErrorStateStruct::Type & aError) : mClusterId(aClusterId) + { + errorState = aError; + } + using super::GetEventId; + using super::GetPriorityLevel; + ClusterId GetClusterId() const { return mClusterId; } + using super::Encode; + using super::kIsFabricScoped; + +private: + ClusterId mClusterId; +}; + +/** + * A class which represents the operational completion event of an Operational State cluster derivation instance. + */ +class GenericOperationCompletionEvent : private app::Clusters::OperationalState::Events::OperationCompletion::Type +{ + using super = app::Clusters::OperationalState::Events::OperationCompletion::Type; + +public: + GenericOperationCompletionEvent(ClusterId aClusterId, uint8_t aCompletionErrorCode, + const Optional> & aTotalOperationalTime = NullOptional, + const Optional> & aPausedTime = NullOptional) : + mClusterId(aClusterId) + { + completionErrorCode = aCompletionErrorCode; + totalOperationalTime = aTotalOperationalTime; + pausedTime = aPausedTime; + } + using super::GetEventId; + using super::GetPriorityLevel; + ClusterId GetClusterId() const { return mClusterId; } + using super::Encode; + using super::kIsFabricScoped; + +private: + ClusterId mClusterId; +}; + +} // namespace OperationalState +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp b/src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp new file mode 100644 index 00000000000000..3c4809401b8db3 --- /dev/null +++ b/src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp @@ -0,0 +1,411 @@ +/* + * + * 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. + */ + +/**************************************************************************** + * @file + * @brief Implementation for the Operational State Server Cluster + ***************************************************************************/ +#include "operational-state-oven-server.h" +#include +#include +#include +#include +#include +#include + +using namespace chip; +using namespace chip::app; +using namespace chip::app::Clusters; +using namespace chip::app::Clusters::OperationalState; +using namespace chip::app::Clusters::OperationalState::Attributes; + +using Status = Protocols::InteractionModel::Status; + +Instance::Instance(Delegate * aDelegate, EndpointId aEndpointId, ClusterId aClusterId) : + CommandHandlerInterface(MakeOptional(aEndpointId), aClusterId), AttributeAccessInterface(MakeOptional(aEndpointId), aClusterId), + mDelegate(aDelegate), mEndpointId(aEndpointId), mClusterId(aClusterId) +{ + mDelegate->SetInstance(this); +} + +Instance::~Instance() +{ + InteractionModelEngine::GetInstance()->UnregisterCommandHandler(this); + unregisterAttributeAccessOverride(this); +} + +CHIP_ERROR Instance::Init() +{ + // Check if the cluster has been selected in zap + if (!emberAfContainsServer(mEndpointId, mClusterId)) + { + ChipLogError(Zcl, "Operational State: The cluster with ID %lu was not enabled in zap.", long(mClusterId)); + return CHIP_ERROR_INVALID_ARGUMENT; + } + + ReturnErrorOnFailure(InteractionModelEngine::GetInstance()->RegisterCommandHandler(this)); + + VerifyOrReturnError(registerAttributeAccessOverride(this), CHIP_ERROR_INCORRECT_STATE); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR Instance::SetCurrentPhase(const DataModel::Nullable & aPhase) +{ + if (!aPhase.IsNull()) + { + if (!IsSupportedPhase(aPhase.Value())) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + } + + DataModel::Nullable oldPhase = mCurrentPhase; + mCurrentPhase = aPhase; + if (mCurrentPhase != oldPhase) + { + MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::CurrentPhase::Id); + } + return CHIP_NO_ERROR; +} + +CHIP_ERROR Instance::SetOperationalState(uint8_t aOpState) +{ + // Error is only allowed to be set by OnOperationalErrorDetected. + if (aOpState == to_underlying(OperationalStateEnum::kError) || !IsSupportedOperationalState(aOpState)) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + + if (mOperationalError.errorStateID != to_underlying(ErrorStateEnum::kNoError)) + { + mOperationalError.Set(to_underlying(ErrorStateEnum::kNoError)); + MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalError::Id); + } + + uint8_t oldState = mOperationalState; + mOperationalState = aOpState; + if (mOperationalState != oldState) + { + MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalState::Id); + } + return CHIP_NO_ERROR; +} + +DataModel::Nullable Instance::GetCurrentPhase() const +{ + return mCurrentPhase; +} + +uint8_t Instance::GetCurrentOperationalState() const +{ + return mOperationalState; +} + +void Instance::GetCurrentOperationalError(GenericOperationalError & error) const +{ + error.Set(mOperationalError.errorStateID, mOperationalError.errorStateLabel, mOperationalError.errorStateDetails); +} + +void Instance::OnOperationalErrorDetected(const Structs::ErrorStateStruct::Type & aError) +{ + ChipLogDetail(Zcl, "OperationalStateServer: OnOperationalErrorDetected"); + // Set the OperationalState attribute to Error + if (mOperationalState != to_underlying(OperationalStateEnum::kError)) + { + mOperationalState = to_underlying(OperationalStateEnum::kError); + MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalState::Id); + } + + // Set the OperationalError attribute + if (!mOperationalError.IsEqual(aError)) + { + mOperationalError.Set(aError.errorStateID, aError.errorStateLabel, aError.errorStateDetails); + MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalError::Id); + } + + // Generate an ErrorDetected event + GenericErrorEvent event(mClusterId, aError); + EventNumber eventNumber; + CHIP_ERROR error = LogEvent(event, mEndpointId, eventNumber); + + if (error != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "OperationalStateServer: Failed to record OperationalError event: %" CHIP_ERROR_FORMAT, error.Format()); + } +} + +void Instance::OnOperationCompletionDetected(uint8_t aCompletionErrorCode, + const Optional> & aTotalOperationalTime, + const Optional> & aPausedTime) const +{ + ChipLogDetail(Zcl, "OperationalStateServer: OnOperationCompletionDetected"); + + GenericOperationCompletionEvent event(mClusterId, aCompletionErrorCode, aTotalOperationalTime, aPausedTime); + EventNumber eventNumber; + CHIP_ERROR error = LogEvent(event, mEndpointId, eventNumber); + + if (error != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "OperationalStateServer: Failed to record OperationCompletion event: %" CHIP_ERROR_FORMAT, + error.Format()); + } +} + +void Instance::ReportOperationalStateListChange() +{ + MatterReportingAttributeChangeCallback(ConcreteAttributePath(mEndpointId, mClusterId, Attributes::OperationalStateList::Id)); +} + +void Instance::ReportPhaseListChange() +{ + MatterReportingAttributeChangeCallback(ConcreteAttributePath(mEndpointId, mClusterId, Attributes::PhaseList::Id)); +} + +bool Instance::IsSupportedPhase(uint8_t aPhase) +{ + GenericOperationalPhase phase = GenericOperationalPhase(DataModel::Nullable()); + if (mDelegate->GetOperationalPhaseAtIndex(aPhase, phase) != CHIP_ERROR_NOT_FOUND) + { + return true; + } + return false; +} + +bool Instance::IsSupportedOperationalState(uint8_t aState) +{ + GenericOperationalState opState; + for (uint8_t i = 0; mDelegate->GetOperationalStateAtIndex(i, opState) != CHIP_ERROR_NOT_FOUND; i++) + { + if (opState.operationalStateID == aState) + { + return true; + } + } + ChipLogDetail(Zcl, "Cannot find an operational state with value %u", aState); + return false; +} + +// private + +template +void Instance::HandleCommand(HandlerContext & handlerContext, FuncT func) +{ + if (!handlerContext.mCommandHandled && (handlerContext.mRequestPath.mCommandId == RequestT::GetCommandId())) + { + RequestT requestPayload; + + // If the command matches what the caller is looking for, let's mark this as being handled + // even if errors happen after this. This ensures that we don't execute any fall-back strategies + // to handle this command since at this point, the caller is taking responsibility for handling + // the command in its entirety, warts and all. + // + handlerContext.SetCommandHandled(); + + if (DataModel::Decode(handlerContext.mPayload, requestPayload) != CHIP_NO_ERROR) + { + handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, + Protocols::InteractionModel::Status::InvalidCommand); + return; + } + + func(handlerContext, requestPayload); + } +} + +// This function is called by the interaction model engine when a command destined for this instance is received. +void Instance::InvokeCommand(HandlerContext & handlerContext) +{ + ChipLogDetail(Zcl, "OperationalState: InvokeCommand"); + switch (handlerContext.mRequestPath.mCommandId) + { + case Commands::Pause::Id: + ChipLogDetail(Zcl, "OperationalState: Entering handling Pause state"); + + HandleCommand( + handlerContext, [this](HandlerContext & ctx, const auto & req) { HandlePauseState(ctx, req); }); + break; + + case Commands::Resume::Id: + ChipLogDetail(Zcl, "OperationalState: Entering handling Resume state"); + + HandleCommand( + handlerContext, [this](HandlerContext & ctx, const auto & req) { HandleResumeState(ctx, req); }); + break; + + case Commands::Start::Id: + ChipLogDetail(Zcl, "OperationalState: Entering handling Start state"); + + HandleCommand( + handlerContext, [this](HandlerContext & ctx, const auto & req) { HandleStartState(ctx, req); }); + break; + + case Commands::Stop::Id: + ChipLogDetail(Zcl, "OperationalState: Entering handling Stop state"); + + HandleCommand(handlerContext, + [this](HandlerContext & ctx, const auto & req) { HandleStopState(ctx, req); }); + break; + } +} + +CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) +{ + ChipLogError(Zcl, "OperationalState: Reading"); + switch (aPath.mAttributeId) + { + case OperationalState::Attributes::OperationalStateList::Id: { + return aEncoder.EncodeList([delegate = mDelegate](const auto & encoder) -> CHIP_ERROR { + GenericOperationalState opState; + size_t index = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + while ((err = delegate->GetOperationalStateAtIndex(index, opState)) == CHIP_NO_ERROR) + { + ReturnErrorOnFailure(encoder.Encode(opState)); + index++; + } + if (err == CHIP_ERROR_NOT_FOUND) + { + return CHIP_NO_ERROR; + } + return err; + }); + } + break; + + case OperationalState::Attributes::OperationalState::Id: { + ChipLogError(Zcl, "OperationalState: H1"); + ReturnErrorOnFailure(aEncoder.Encode(GetCurrentOperationalState())); + } + break; + + case OperationalState::Attributes::OperationalError::Id: { + ReturnErrorOnFailure(aEncoder.Encode(mOperationalError)); + } + break; + + case OperationalState::Attributes::PhaseList::Id: { + GenericOperationalPhase phase = GenericOperationalPhase(DataModel::Nullable()); + size_t index = 0; + + if (mDelegate->GetOperationalPhaseAtIndex(index, phase) == CHIP_ERROR_NOT_FOUND || phase.IsMissing()) + { + return aEncoder.EncodeNull(); + } + return aEncoder.EncodeList([&](const auto & encoder) -> CHIP_ERROR { + while (this->mDelegate->GetOperationalPhaseAtIndex(index, phase) != CHIP_ERROR_NOT_FOUND) + { + ReturnErrorOnFailure(encoder.Encode(phase.mPhaseName)); + index++; + } + return CHIP_NO_ERROR; + }); + } + break; + + case OperationalState::Attributes::CurrentPhase::Id: { + ReturnErrorOnFailure(aEncoder.Encode(GetCurrentPhase())); + } + break; + + case OperationalState::Attributes::CountdownTime::Id: { + ReturnErrorOnFailure(aEncoder.Encode(mDelegate->GetCountdownTime())); + } + break; + } + return CHIP_NO_ERROR; +} + +void Instance::HandlePauseState(HandlerContext & ctx, const Commands::Pause::DecodableType & req) +{ + ChipLogDetail(Zcl, "OperationalState: HandlePauseState"); + + GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); + uint8_t opState = GetCurrentOperationalState(); + + if (opState != to_underlying(OperationalStateEnum::kPaused) && opState != to_underlying(OperationalStateEnum::kRunning)) + { + err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); + } + else if (opState == to_underlying(OperationalStateEnum::kRunning)) + { + mDelegate->HandlePauseStateCallback(err); + } + + Commands::OperationalCommandResponse::Type response; + response.commandResponseState = err; + + ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); +} + +void Instance::HandleStopState(HandlerContext & ctx, const Commands::Stop::DecodableType & req) +{ + ChipLogDetail(Zcl, "OperationalState: HandleStopState"); + + GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); + uint8_t opState = GetCurrentOperationalState(); + + if (opState != to_underlying(OperationalStateEnum::kStopped)) + { + mDelegate->HandleStopStateCallback(err); + } + + Commands::OperationalCommandResponse::Type response; + response.commandResponseState = err; + + ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); +} + +void Instance::HandleStartState(HandlerContext & ctx, const Commands::Start::DecodableType & req) +{ + ChipLogDetail(Zcl, "OperationalState: HandleStartState"); + + GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); + uint8_t opState = GetCurrentOperationalState(); + + if (opState != to_underlying(OperationalStateEnum::kRunning)) + { + mDelegate->HandleStartStateCallback(err); + } + + Commands::OperationalCommandResponse::Type response; + response.commandResponseState = err; + + ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); +} + +void Instance::HandleResumeState(HandlerContext & ctx, const Commands::Resume::DecodableType & req) +{ + ChipLogDetail(Zcl, "OperationalState: HandleResumeState"); + + GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); + uint8_t opState = GetCurrentOperationalState(); + + if (opState != to_underlying(OperationalStateEnum::kPaused) && opState != to_underlying(OperationalStateEnum::kRunning)) + { + err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); + } + else if (opState == to_underlying(OperationalStateEnum::kPaused)) + { + mDelegate->HandleResumeStateCallback(err); + } + + Commands::OperationalCommandResponse::Type response; + response.commandResponseState = err; + + ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); +} diff --git a/src/app/clusters/operational-state-oven-server/operational-state-oven-server.h b/src/app/clusters/operational-state-oven-server/operational-state-oven-server.h new file mode 100644 index 00000000000000..23ebba36817d22 --- /dev/null +++ b/src/app/clusters/operational-state-oven-server/operational-state-oven-server.h @@ -0,0 +1,280 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "operational-state-oven-cluster-objects.h" +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { +namespace OperationalState { + +class Uncopyable +{ +protected: + Uncopyable() {} + ~Uncopyable() = default; + +private: + Uncopyable(const Uncopyable &) = delete; + Uncopyable & operator=(const Uncopyable &) = delete; +}; + +class Delegate; + +/** + * Instance is a class that represents an instance of a derivation of the operational state cluster. + * It implements CommandHandlerInterface so it can generically handle commands for any derivation cluster id. + */ +class Instance : public CommandHandlerInterface, public AttributeAccessInterface, public Uncopyable +{ +public: + /** + * Creates an operational state cluster instance. The Init() function needs to be called for this instance + * to be registered and called by the interaction model at the appropriate times. + * It is possible to set the CurrentPhase and OperationalState via the Set... methods before calling Init(). + * @param aDelegate A pointer to the delegate to be used by this server. + * Note: the caller must ensure that the delegate lives throughout the instance's lifetime. + * @param aEndpointId The endpoint on which this cluster exists. This must match the zap configuration. + * @param aClusterId The ID of the operational state derived cluster to be instantiated. + */ + Instance(Delegate * aDelegate, EndpointId aEndpointId, ClusterId aClusterId); + + ~Instance() override; + + /** + * Initialise the operational state server instance. + * This function must be called after defining an Instance class object. + * @return Returns an error if the given endpoint and cluster ID have not been enabled in zap or if the + * CommandHandler or AttributeHandler registration fails, else returns CHIP_NO_ERROR. + */ + CHIP_ERROR Init(); + + // Attribute setters + /** + * Set operational phase. + * @param aPhase The operational phase that should now be the current one. + * @return CHIP_ERROR_INVALID_ARGUMENT if aPhase is an invalid value. CHIP_NO_ERROR if set was successful. + */ + CHIP_ERROR SetCurrentPhase(const app::DataModel::Nullable & aPhase); + + /** + * Set current operational state to aOpState and the operational error to kNoError. + * NOTE: This method cannot be used to set the error state. The error state must be set via the + * OnOperationalErrorDetected method. + * @param aOpState The operational state that should now be the current one. + * @return CHIP_ERROR_INVALID_ARGUMENT if aOpState is an invalid value. CHIP_NO_ERROR if set was successful. + */ + CHIP_ERROR SetOperationalState(uint8_t aOpState); + + // Attribute getters + /** + * Get current phase. + * @return The current phase. + */ + app::DataModel::Nullable GetCurrentPhase() const; + + /** + * Get the current operational state. + * @return The current operational state value. + */ + uint8_t GetCurrentOperationalState() const; + + /** + * Get current operational error. + * @param error The GenericOperationalError to fill with the current operational error value + */ + void GetCurrentOperationalError(GenericOperationalError & error) const; + + // Event triggers + /** + * @brief Called when the Node detects a OperationalError has been raised. + * Note: This function also sets the OperationalState attribute to Error. + * @param aError OperationalError which detects + */ + void OnOperationalErrorDetected(const Structs::ErrorStateStruct::Type & aError); + + /** + * @brief Called when the Node detects a OperationCompletion has been raised. + * @param aCompletionErrorCode CompletionErrorCode + * @param aTotalOperationalTime TotalOperationalTime + * @param aPausedTime PausedTime + */ + void OnOperationCompletionDetected(uint8_t aCompletionErrorCode, + const Optional> & aTotalOperationalTime = NullOptional, + const Optional> & aPausedTime = NullOptional) const; + + // List change reporting + /** + * Reports that the contents of the operational state list has changed. + * The device SHALL call this method whenever it changes the operational state list. + */ + void ReportOperationalStateListChange(); + + /** + * Reports that the contents of the phase list has changed. + * The device SHALL call this method whenever it changes the phase list. + */ + void ReportPhaseListChange(); + + /** + * This function returns true if the phase value given exists in the PhaseList attribute, otherwise it returns false. + */ + bool IsSupportedPhase(uint8_t aPhase); + + /** + * This function returns true if the operational state value given exists in the OperationalStateList attribute, + * otherwise it returns false. + */ + bool IsSupportedOperationalState(uint8_t aState); + +private: + Delegate * mDelegate; + + EndpointId mEndpointId; + ClusterId mClusterId; + + // Attribute Data Store + app::DataModel::Nullable mCurrentPhase; + uint8_t mOperationalState = 0; // assume 0 for now. + GenericOperationalError mOperationalError = to_underlying(ErrorStateEnum::kNoError); + + // Inherited from CommandHandlerInterface + template + void HandleCommand(HandlerContext & handlerContext, FuncT func); + + // Inherited from CommandHandlerInterface + void InvokeCommand(HandlerContext & ctx) override; + + /** + * IM-level implementation of read + * @return appropriately mapped CHIP_ERROR if applicable (may return CHIP_IM_GLOBAL_STATUS errors) + */ + CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override; + + /** + * Handle Command: Pause. + */ + void HandlePauseState(HandlerContext & ctx, const Commands::Pause::DecodableType & req); + + /** + * Handle Command: Stop. + */ + void HandleStopState(HandlerContext & ctx, const Commands::Stop::DecodableType & req); + + /** + * Handle Command: Start. + */ + void HandleStartState(HandlerContext & ctx, const Commands::Start::DecodableType & req); + + /** + * Handle Command: Resume. + */ + void HandleResumeState(HandlerContext & ctx, const Commands::Resume::DecodableType & req); +}; + +/** + * A delegate to handle application logic of the Operational State aliased Cluster. + * The delegate API assumes there will be separate delegate objects for each cluster instance. + * (i.e. each separate operational state cluster derivation, on each separate endpoint), + * since the delegate methods are not handed the cluster id or endpoint. + */ +class Delegate +{ +public: + Delegate() = default; + + virtual ~Delegate() = default; + + /** + * Get the countdown time. + * NOTE: Changes to this attribute should not be reported. + * From the spec: Changes to this value SHALL NOT be reported in a subscription. + * @return The current countdown time. + */ + virtual app::DataModel::Nullable GetCountdownTime() = 0; + + /** + * Fills in the provided GenericOperationalState with the state at index `index` if there is one, + * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of states. + * Note: This is used by the SDK to populate the operational state list attribute. If the contents of this list changes, + * the device SHALL call the Instance's ReportOperationalStateListChange method to report that this attribute has changed. + * @param index The index of the state, with 0 representing the first state. + * @param operationalState The GenericOperationalState is filled. + */ + virtual CHIP_ERROR GetOperationalStateAtIndex(size_t index, GenericOperationalState & operationalState) = 0; + + /** + * Fills in the provided GenericOperationalPhase with the phase at index `index` if there is one, + * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of phases. + * Note: This is used by the SDK to populate the phase list attribute. If the contents of this list changes, the + * device SHALL call the Instance's ReportPhaseListChange method to report that this attribute has changed. + * @param index The index of the phase, with 0 representing the first phase. + * @param operationalPhase The GenericOperationalPhase is filled. + */ + virtual CHIP_ERROR GetOperationalPhaseAtIndex(size_t index, GenericOperationalPhase & operationalPhase) = 0; + + // command callback + /** + * Handle Command Callback in application: Pause + * @param[out] err operational error after callback. + */ + virtual void HandlePauseStateCallback(GenericOperationalError & err) = 0; + + /** + * Handle Command Callback in application: Resume + * @param[out] err operational error after callback. + */ + virtual void HandleResumeStateCallback(GenericOperationalError & err) = 0; + + /** + * Handle Command Callback in application: Start + * @param[out] err operational error after callback. + */ + virtual void HandleStartStateCallback(GenericOperationalError & err) = 0; + + /** + * Handle Command Callback in application: Stop + * @param[out] err operational error after callback. + */ + virtual void HandleStopStateCallback(GenericOperationalError & err) = 0; + +private: + friend class Instance; + + Instance * mInstance = nullptr; + + /** + * This method is used by the SDK to set the instance pointer. This is done during the instantiation of a Instance object. + * @param aInstance A pointer to the Instance object related to this delegate object. + */ + void SetInstance(Instance * aInstance) { mInstance = aInstance; } + +protected: + Instance * GetInstance() const { return mInstance; } +}; + +} // namespace OperationalState +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/src/app/common/templates/config-data.yaml b/src/app/common/templates/config-data.yaml index 2605704fa89e0a..2ee03c124bb769 100644 --- a/src/app/common/templates/config-data.yaml +++ b/src/app/common/templates/config-data.yaml @@ -24,6 +24,7 @@ CommandHandlerInterfaceOnlyClusters: - Dishwasher Mode - Laundry Washer Mode - Oven Mode + - Oven Cavity Operational State - Refrigerator And Temperature Controlled Cabinet Mode - Operational State - Activated Carbon Filter Monitoring diff --git a/src/app/util/util.cpp b/src/app/util/util.cpp index e7fa8c2b2374d8..329de98697c376 100644 --- a/src/app/util/util.cpp +++ b/src/app/util/util.cpp @@ -158,6 +158,7 @@ void MatterRefrigeratorAndTemperatureControlledCabinetModePluginServerInitCallba void MatterOperationalStatePluginServerInitCallback() {} void MatterRvcOperationalStatePluginServerInitCallback() {} void MatterOvenModePluginServerInitCallback() {} +void MatterOvenCavityOperationalStatePluginServerInitCallback() {} void MatterDishwasherAlarmPluginServerInitCallback() {} void MatterMicrowaveOvenModePluginServerInitCallback() {} // **************************************** diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 9c1c09406ad207..78ff3188a4be5b 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -601,7 +601,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -653,7 +653,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -1289,7 +1289,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -1841,7 +1841,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -1948,75 +1948,6 @@ "source": "client", "isIncoming": 0, "isEnabled": 1 - }, - { - "name": "StayActiveResponse", - "code": 4, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "client", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "client", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - } - ] - }, - { - "name": "Timer", - "code": 71, - "mfgCode": null, - "define": "TIMER_CLUSTER", - "side": "client", - "enabled": 1, - "apiMaturity": "provisional", - "commands": [ - { - "name": "SetTimer", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "AddTime", - "code": 2, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 } ], "attributes": [ @@ -2131,49 +2062,7 @@ "side": "client", "type": "bitmap32", "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "client", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - } - ] - }, - { - "name": "Laundry Dryer Controls", - "code": 74, - "mfgCode": null, - "define": "LAUNDRY_DRYER_CONTROLS_CLUSTER", - "side": "client", - "enabled": 1, - "attributes": [ - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "client", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "0", @@ -2288,7 +2177,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2348,7 +2237,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2450,7 +2339,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2510,7 +2399,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2664,7 +2553,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2706,7 +2595,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2837,7 +2726,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -3058,7 +2947,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -3100,110 +2989,6 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "client", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - } - ] - }, - { - "name": "Device Energy Management", - "code": 152, - "mfgCode": null, - "define": "DEVICE_ENERGY_MANAGEMENT_CLUSTER", - "side": "client", - "enabled": 1, - "apiMaturity": "provisional", - "attributes": [ - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "client", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "client", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - } - ] - }, - { - "name": "Energy EVSE", - "code": 153, - "mfgCode": null, - "define": "ENERGY_EVSE_CLUSTER", - "side": "client", - "enabled": 1, - "apiMaturity": "provisional", - "commands": [ - { - "name": "Disable", - "code": 1, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "EnableCharging", - "code": 2, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "client", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, "defaultValue": "0", "reportable": 1, "minInterval": 1, @@ -4119,7 +3904,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4161,7 +3946,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4203,7 +3988,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4245,7 +4030,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4287,7 +4072,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4329,7 +4114,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4371,7 +4156,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4413,7 +4198,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4455,7 +4240,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4497,7 +4282,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java index 8eb7fcdcee4b3a..784fef07bf62af 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java @@ -31012,353 +31012,6 @@ public void onSuccess(byte[] tlv) { } } - public static class EnergyPreferenceCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 155L; - - private static final long ENERGY_BALANCES_ATTRIBUTE_ID = 0L; - private static final long CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID = 1L; - private static final long ENERGY_PRIORITIES_ATTRIBUTE_ID = 2L; - private static final long LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID = 3L; - private static final long CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID = 4L; - 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 EnergyPreferenceCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId, CLUSTER_ID); - } - - @Override - @Deprecated - public long initWithDevice(long devicePtr, int endpointId) { - return 0L; - } - - public interface EnergyBalancesAttributeCallback extends BaseAttributeCallback { - void onSuccess(List value); - } - - public interface EnergyPrioritiesAttributeCallback extends BaseAttributeCallback { - void onSuccess(List value); - } - - public interface LowPowerModeSensitivitiesAttributeCallback extends BaseAttributeCallback { - void onSuccess(List 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 readEnergyBalancesAttribute( - EnergyBalancesAttributeCallback callback) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_BALANCES_ATTRIBUTE_ID); - - readAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - callback.onSuccess(value); - } - }, ENERGY_BALANCES_ATTRIBUTE_ID, true); - } - - public void subscribeEnergyBalancesAttribute( - EnergyBalancesAttributeCallback callback, int minInterval, int maxInterval) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_BALANCES_ATTRIBUTE_ID); - - subscribeAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - } - }, ENERGY_BALANCES_ATTRIBUTE_ID, minInterval, maxInterval); - } - - public void readCurrentEnergyBalanceAttribute( - IntegerAttributeCallback callback) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID); - - readAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - callback.onSuccess(value); - } - }, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID, true); - } - - public void writeCurrentEnergyBalanceAttribute(DefaultClusterCallback callback, Integer value) { - writeCurrentEnergyBalanceAttribute(callback, value, 0); - } - - public void writeCurrentEnergyBalanceAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - BaseTLVType tlvValue = new UIntType(value); - writeAttribute(new WriteAttributesCallbackImpl(callback), CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); - } - - public void subscribeCurrentEnergyBalanceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID); - - subscribeAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - } - }, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID, minInterval, maxInterval); - } - - public void readEnergyPrioritiesAttribute( - EnergyPrioritiesAttributeCallback callback) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_PRIORITIES_ATTRIBUTE_ID); - - readAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - callback.onSuccess(value); - } - }, ENERGY_PRIORITIES_ATTRIBUTE_ID, true); - } - - public void subscribeEnergyPrioritiesAttribute( - EnergyPrioritiesAttributeCallback callback, int minInterval, int maxInterval) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_PRIORITIES_ATTRIBUTE_ID); - - subscribeAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - } - }, ENERGY_PRIORITIES_ATTRIBUTE_ID, minInterval, maxInterval); - } - - public void readLowPowerModeSensitivitiesAttribute( - LowPowerModeSensitivitiesAttributeCallback callback) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID); - - readAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - callback.onSuccess(value); - } - }, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID, true); - } - - public void subscribeLowPowerModeSensitivitiesAttribute( - LowPowerModeSensitivitiesAttributeCallback callback, int minInterval, int maxInterval) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID); - - subscribeAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - } - }, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID, minInterval, maxInterval); - } - - public void readCurrentLowPowerModeSensitivityAttribute( - IntegerAttributeCallback callback) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID); - - readAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - callback.onSuccess(value); - } - }, CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID, true); - } - - public void writeCurrentLowPowerModeSensitivityAttribute(DefaultClusterCallback callback, Integer value) { - writeCurrentLowPowerModeSensitivityAttribute(callback, value, 0); - } - - public void writeCurrentLowPowerModeSensitivityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - BaseTLVType tlvValue = new UIntType(value); - writeAttribute(new WriteAttributesCallbackImpl(callback), CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); - } - - public void subscribeCurrentLowPowerModeSensitivityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID); - - subscribeAttribute(new ReportCallbackImpl(callback, path) { - @Override - public void onSuccess(byte[] tlv) { - Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); - } - }, CURRENT_LOW_POWER_MODE_SENSITIVITY_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 DoorLockCluster extends BaseChipCluster { public static final long CLUSTER_ID = 257L; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java index 9f5c25260c131b..46817d28431755 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java @@ -449,34 +449,6 @@ public String toString() { return output.toString(); } } -public static class BasicInformationClusterShutDownEvent { - - public BasicInformationClusterShutDownEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static BasicInformationClusterShutDownEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new BasicInformationClusterShutDownEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BasicInformationClusterShutDownEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class BasicInformationClusterLeaveEvent { public Integer fabricIndex; private static final long FABRIC_INDEX_ID = 0L; @@ -1560,34 +1532,6 @@ public String toString() { return output.toString(); } } -public static class TimeSynchronizationClusterDSTTableEmptyEvent { - - public TimeSynchronizationClusterDSTTableEmptyEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static TimeSynchronizationClusterDSTTableEmptyEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new TimeSynchronizationClusterDSTTableEmptyEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TimeSynchronizationClusterDSTTableEmptyEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class TimeSynchronizationClusterDSTStatusEvent { public Boolean DSTOffsetActive; private static final long D_S_T_OFFSET_ACTIVE_ID = 0L; @@ -1695,62 +1639,6 @@ public String toString() { return output.toString(); } } -public static class TimeSynchronizationClusterTimeFailureEvent { - - public TimeSynchronizationClusterTimeFailureEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static TimeSynchronizationClusterTimeFailureEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new TimeSynchronizationClusterTimeFailureEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TimeSynchronizationClusterTimeFailureEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class TimeSynchronizationClusterMissingTrustedTimeSourceEvent { - - public TimeSynchronizationClusterMissingTrustedTimeSourceEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static TimeSynchronizationClusterMissingTrustedTimeSourceEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new TimeSynchronizationClusterMissingTrustedTimeSourceEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TimeSynchronizationClusterMissingTrustedTimeSourceEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class BridgedDeviceBasicInformationClusterStartUpEvent { public Long softwareVersion; private static final long SOFTWARE_VERSION_ID = 0L; @@ -1797,62 +1685,6 @@ public String toString() { return output.toString(); } } -public static class BridgedDeviceBasicInformationClusterShutDownEvent { - - public BridgedDeviceBasicInformationClusterShutDownEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static BridgedDeviceBasicInformationClusterShutDownEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new BridgedDeviceBasicInformationClusterShutDownEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedDeviceBasicInformationClusterShutDownEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class BridgedDeviceBasicInformationClusterLeaveEvent { - - public BridgedDeviceBasicInformationClusterLeaveEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static BridgedDeviceBasicInformationClusterLeaveEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new BridgedDeviceBasicInformationClusterLeaveEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedDeviceBasicInformationClusterLeaveEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class BridgedDeviceBasicInformationClusterReachableChangedEvent { public Boolean reachableNewValue; private static final long REACHABLE_NEW_VALUE_ID = 0L; @@ -2676,146 +2508,6 @@ public String toString() { return output.toString(); } } -public static class SmokeCoAlarmClusterHardwareFaultEvent { - - public SmokeCoAlarmClusterHardwareFaultEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static SmokeCoAlarmClusterHardwareFaultEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new SmokeCoAlarmClusterHardwareFaultEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SmokeCoAlarmClusterHardwareFaultEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class SmokeCoAlarmClusterEndOfServiceEvent { - - public SmokeCoAlarmClusterEndOfServiceEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static SmokeCoAlarmClusterEndOfServiceEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new SmokeCoAlarmClusterEndOfServiceEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SmokeCoAlarmClusterEndOfServiceEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class SmokeCoAlarmClusterSelfTestCompleteEvent { - - public SmokeCoAlarmClusterSelfTestCompleteEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static SmokeCoAlarmClusterSelfTestCompleteEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new SmokeCoAlarmClusterSelfTestCompleteEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SmokeCoAlarmClusterSelfTestCompleteEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class SmokeCoAlarmClusterAlarmMutedEvent { - - public SmokeCoAlarmClusterAlarmMutedEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static SmokeCoAlarmClusterAlarmMutedEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new SmokeCoAlarmClusterAlarmMutedEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SmokeCoAlarmClusterAlarmMutedEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class SmokeCoAlarmClusterMuteEndedEvent { - - public SmokeCoAlarmClusterMuteEndedEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static SmokeCoAlarmClusterMuteEndedEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new SmokeCoAlarmClusterMuteEndedEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SmokeCoAlarmClusterMuteEndedEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class SmokeCoAlarmClusterInterconnectSmokeAlarmEvent { public Integer alarmSeverityLevel; private static final long ALARM_SEVERITY_LEVEL_ID = 0L; @@ -2908,34 +2600,6 @@ public String toString() { return output.toString(); } } -public static class SmokeCoAlarmClusterAllClearEvent { - - public SmokeCoAlarmClusterAllClearEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static SmokeCoAlarmClusterAllClearEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new SmokeCoAlarmClusterAllClearEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SmokeCoAlarmClusterAllClearEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class DishwasherAlarmClusterNotifyEvent { public Long active; public Long inactive; @@ -3788,34 +3452,6 @@ public String toString() { return output.toString(); } } -public static class DeviceEnergyManagementClusterPowerAdjustStartEvent { - - public DeviceEnergyManagementClusterPowerAdjustStartEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static DeviceEnergyManagementClusterPowerAdjustStartEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new DeviceEnergyManagementClusterPowerAdjustStartEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DeviceEnergyManagementClusterPowerAdjustStartEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class DeviceEnergyManagementClusterPowerAdjustEndEvent { public Integer cause; public Long duration; @@ -3892,62 +3528,6 @@ public String toString() { return output.toString(); } } -public static class DeviceEnergyManagementClusterPausedEvent { - - public DeviceEnergyManagementClusterPausedEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static DeviceEnergyManagementClusterPausedEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new DeviceEnergyManagementClusterPausedEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DeviceEnergyManagementClusterPausedEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class DeviceEnergyManagementClusterResumedEvent { - - public DeviceEnergyManagementClusterResumedEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static DeviceEnergyManagementClusterResumedEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new DeviceEnergyManagementClusterResumedEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DeviceEnergyManagementClusterResumedEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class EnergyEvseClusterEVConnectedEvent { public Long sessionID; private static final long SESSION_I_D_ID = 0L; @@ -4889,482 +4469,6 @@ public String toString() { return output.toString(); } } -public static class PumpConfigurationAndControlClusterSupplyVoltageLowEvent { - - public PumpConfigurationAndControlClusterSupplyVoltageLowEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterSupplyVoltageLowEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterSupplyVoltageLowEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterSupplyVoltageLowEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterSupplyVoltageHighEvent { - - public PumpConfigurationAndControlClusterSupplyVoltageHighEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterSupplyVoltageHighEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterSupplyVoltageHighEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterSupplyVoltageHighEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterPowerMissingPhaseEvent { - - public PumpConfigurationAndControlClusterPowerMissingPhaseEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterPowerMissingPhaseEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterPowerMissingPhaseEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterPowerMissingPhaseEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterSystemPressureLowEvent { - - public PumpConfigurationAndControlClusterSystemPressureLowEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterSystemPressureLowEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterSystemPressureLowEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterSystemPressureLowEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterSystemPressureHighEvent { - - public PumpConfigurationAndControlClusterSystemPressureHighEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterSystemPressureHighEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterSystemPressureHighEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterSystemPressureHighEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterDryRunningEvent { - - public PumpConfigurationAndControlClusterDryRunningEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterDryRunningEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterDryRunningEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterDryRunningEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterMotorTemperatureHighEvent { - - public PumpConfigurationAndControlClusterMotorTemperatureHighEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterMotorTemperatureHighEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterMotorTemperatureHighEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterMotorTemperatureHighEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent { - - public PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterElectronicTemperatureHighEvent { - - public PumpConfigurationAndControlClusterElectronicTemperatureHighEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterElectronicTemperatureHighEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterElectronicTemperatureHighEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterElectronicTemperatureHighEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterPumpBlockedEvent { - - public PumpConfigurationAndControlClusterPumpBlockedEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterPumpBlockedEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterPumpBlockedEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterPumpBlockedEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterSensorFailureEvent { - - public PumpConfigurationAndControlClusterSensorFailureEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterSensorFailureEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterSensorFailureEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterSensorFailureEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent { - - public PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterElectronicFatalFailureEvent { - - public PumpConfigurationAndControlClusterElectronicFatalFailureEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterElectronicFatalFailureEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterElectronicFatalFailureEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterElectronicFatalFailureEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterGeneralFaultEvent { - - public PumpConfigurationAndControlClusterGeneralFaultEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterGeneralFaultEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterGeneralFaultEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterGeneralFaultEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterLeakageEvent { - - public PumpConfigurationAndControlClusterLeakageEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterLeakageEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterLeakageEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterLeakageEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterAirDetectionEvent { - - public PumpConfigurationAndControlClusterAirDetectionEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterAirDetectionEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterAirDetectionEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterAirDetectionEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} -public static class PumpConfigurationAndControlClusterTurbineOperationEvent { - - public PumpConfigurationAndControlClusterTurbineOperationEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static PumpConfigurationAndControlClusterTurbineOperationEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new PumpConfigurationAndControlClusterTurbineOperationEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PumpConfigurationAndControlClusterTurbineOperationEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class TargetNavigatorClusterTargetUpdatedEvent { public ArrayList targetList; public Integer currentTarget; @@ -5653,34 +4757,6 @@ public String toString() { return output.toString(); } } -public static class ContentControlClusterRemainingScreenTimeExpiredEvent { - - public ContentControlClusterRemainingScreenTimeExpiredEvent( - ) { - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - - return new StructType(values); - } - - public static ContentControlClusterRemainingScreenTimeExpiredEvent decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - return new ContentControlClusterRemainingScreenTimeExpiredEvent( - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentControlClusterRemainingScreenTimeExpiredEvent {\n"); - output.append("}\n"); - return output.toString(); - } -} public static class UnitTestingClusterTestEventEvent { public Integer arg1; public Integer arg2; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java index 9e36accf1b129a..68baadbbe4d8fc 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java @@ -7351,67 +7351,6 @@ public String toString() { return output.toString(); } } -public static class EnergyPreferenceClusterBalanceStruct { - public Integer step; - public Optional label; - private static final long STEP_ID = 0L; - private static final long LABEL_ID = 1L; - - public EnergyPreferenceClusterBalanceStruct( - Integer step, - Optional label - ) { - this.step = step; - this.label = label; - } - - public StructType encodeTlv() { - ArrayList values = new ArrayList<>(); - values.add(new StructElement(STEP_ID, new UIntType(step))); - values.add(new StructElement(LABEL_ID, label.map((nonOptionallabel) -> new StringType(nonOptionallabel)).orElse(new EmptyType()))); - - return new StructType(values); - } - - public static EnergyPreferenceClusterBalanceStruct decodeTlv(BaseTLVType tlvValue) { - if (tlvValue == null || tlvValue.type() != TLVType.Struct) { - return null; - } - Integer step = null; - Optional label = Optional.empty(); - for (StructElement element: ((StructType)tlvValue).value()) { - if (element.contextTagNum() == STEP_ID) { - if (element.value(BaseTLVType.class).type() == TLVType.UInt) { - UIntType castingValue = element.value(UIntType.class); - step = castingValue.value(Integer.class); - } - } else if (element.contextTagNum() == LABEL_ID) { - if (element.value(BaseTLVType.class).type() == TLVType.String) { - StringType castingValue = element.value(StringType.class); - label = Optional.of(castingValue.value(String.class)); - } - } - } - return new EnergyPreferenceClusterBalanceStruct( - step, - label - ); - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("EnergyPreferenceClusterBalanceStruct {\n"); - output.append("\tstep: "); - output.append(step); - output.append("\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} public static class DoorLockClusterCredentialStruct { public Integer credentialType; public Integer credentialIndex; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index a1be6ce8ae6bd1..1f02636b05aab7 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -235,9 +235,6 @@ public static BaseCluster getCluster(long clusterId) { if (clusterId == EnergyEvse.ID) { return new EnergyEvse(); } - if (clusterId == EnergyPreference.ID) { - return new EnergyPreference(); - } if (clusterId == DoorLock.ID) { return new DoorLock(); } @@ -9753,111 +9750,6 @@ public long getCommandID(String name) throws IllegalArgumentException { return Command.valueOf(name).getID(); } } - public static class EnergyPreference implements BaseCluster { - public static final long ID = 155L; - public long getID() { - return ID; - } - - public enum Attribute { - EnergyBalances(0L), - CurrentEnergyBalance(1L), - EnergyPriorities(2L), - LowPowerModeSensitivities(3L), - CurrentLowPowerModeSensitivity(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - 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(); - } - }@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 DoorLock implements BaseCluster { public static final long ID = 257L; 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 10007746d7dd7b..a2ebb9c79ced48 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java @@ -10915,153 +10915,6 @@ public void onError(Exception ex) { } } - public static class DelegatedEnergyPreferenceClusterEnergyBalancesAttributeCallback implements ChipClusters.EnergyPreferenceCluster.EnergyBalancesAttributeCallback, 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 DelegatedEnergyPreferenceClusterEnergyPrioritiesAttributeCallback implements ChipClusters.EnergyPreferenceCluster.EnergyPrioritiesAttributeCallback, 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 DelegatedEnergyPreferenceClusterLowPowerModeSensitivitiesAttributeCallback implements ChipClusters.EnergyPreferenceCluster.LowPowerModeSensitivitiesAttributeCallback, 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 DelegatedEnergyPreferenceClusterGeneratedCommandListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedEnergyPreferenceClusterAcceptedCommandListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedEnergyPreferenceClusterEventListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedEnergyPreferenceClusterAttributeListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedDoorLockClusterGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @@ -20054,10 +19907,6 @@ public Map initializeClusterMap() { (ptr, endpointId) -> new ChipClusters.EnergyEvseCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("energyEvse", energyEvseClusterInfo); - ClusterInfo energyPreferenceClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.EnergyPreferenceCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("energyPreference", energyPreferenceClusterInfo); - ClusterInfo doorLockClusterInfo = new ClusterInfo( (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("doorLock", doorLockClusterInfo); @@ -20303,7 +20152,6 @@ public void combineCommand(Map destination, Map> getCommandMap() { commandMap.put("energyEvse", energyEvseClusterInteractionInfoMap); - Map energyPreferenceClusterInteractionInfoMap = new LinkedHashMap<>(); - - commandMap.put("energyPreference", energyPreferenceClusterInteractionInfoMap); - Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); Map doorLocklockDoorCommandParams = 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 64a4a7a1ff08c7..9199ac3dc8ab96 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -9750,131 +9750,6 @@ private static Map readEnergyEvseInteractionInfo() { return result; } - private static Map readEnergyPreferenceInteractionInfo() { - Map result = new LinkedHashMap<>();Map readEnergyPreferenceEnergyBalancesCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceEnergyBalancesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readEnergyBalancesAttribute( - (ChipClusters.EnergyPreferenceCluster.EnergyBalancesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterEnergyBalancesAttributeCallback(), - readEnergyPreferenceEnergyBalancesCommandParams - ); - result.put("readEnergyBalancesAttribute", readEnergyPreferenceEnergyBalancesAttributeInteractionInfo); - Map readEnergyPreferenceCurrentEnergyBalanceCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readCurrentEnergyBalanceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEnergyPreferenceCurrentEnergyBalanceCommandParams - ); - result.put("readCurrentEnergyBalanceAttribute", readEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo); - Map readEnergyPreferenceEnergyPrioritiesCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceEnergyPrioritiesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readEnergyPrioritiesAttribute( - (ChipClusters.EnergyPreferenceCluster.EnergyPrioritiesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterEnergyPrioritiesAttributeCallback(), - readEnergyPreferenceEnergyPrioritiesCommandParams - ); - result.put("readEnergyPrioritiesAttribute", readEnergyPreferenceEnergyPrioritiesAttributeInteractionInfo); - Map readEnergyPreferenceLowPowerModeSensitivitiesCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceLowPowerModeSensitivitiesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readLowPowerModeSensitivitiesAttribute( - (ChipClusters.EnergyPreferenceCluster.LowPowerModeSensitivitiesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterLowPowerModeSensitivitiesAttributeCallback(), - readEnergyPreferenceLowPowerModeSensitivitiesCommandParams - ); - result.put("readLowPowerModeSensitivitiesAttribute", readEnergyPreferenceLowPowerModeSensitivitiesAttributeInteractionInfo); - Map readEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readCurrentLowPowerModeSensitivityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams - ); - result.put("readCurrentLowPowerModeSensitivityAttribute", readEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo); - Map readEnergyPreferenceGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.EnergyPreferenceCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterGeneratedCommandListAttributeCallback(), - readEnergyPreferenceGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readEnergyPreferenceGeneratedCommandListAttributeInteractionInfo); - Map readEnergyPreferenceAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.EnergyPreferenceCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterAcceptedCommandListAttributeCallback(), - readEnergyPreferenceAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readEnergyPreferenceAcceptedCommandListAttributeInteractionInfo); - Map readEnergyPreferenceEventListCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readEventListAttribute( - (ChipClusters.EnergyPreferenceCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterEventListAttributeCallback(), - readEnergyPreferenceEventListCommandParams - ); - result.put("readEventListAttribute", readEnergyPreferenceEventListAttributeInteractionInfo); - Map readEnergyPreferenceAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readAttributeListAttribute( - (ChipClusters.EnergyPreferenceCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterAttributeListAttributeCallback(), - readEnergyPreferenceAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readEnergyPreferenceAttributeListAttributeInteractionInfo); - Map readEnergyPreferenceFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEnergyPreferenceFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readEnergyPreferenceFeatureMapAttributeInteractionInfo); - Map readEnergyPreferenceClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readEnergyPreferenceClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEnergyPreferenceClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readEnergyPreferenceClusterRevisionAttributeInteractionInfo); - - return result; - } private static Map readDoorLockInteractionInfo() { Map result = new LinkedHashMap<>();Map readDoorLockLockStateCommandParams = new LinkedHashMap(); InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( @@ -19943,7 +19818,6 @@ public Map> getReadAttributeMap() { put("demandResponseLoadControl", readDemandResponseLoadControlInteractionInfo()); put("deviceEnergyManagement", readDeviceEnergyManagementInteractionInfo()); put("energyEvse", readEnergyEvseInteractionInfo()); - put("energyPreference", readEnergyPreferenceInteractionInfo()); put("doorLock", readDoorLockInteractionInfo()); put("windowCovering", readWindowCoveringInteractionInfo()); put("barrierControl", readBarrierControlInteractionInfo()); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index c3003c33ed19e0..4d3c50d8d8d89a 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -1352,52 +1352,6 @@ public Map> getWriteAttributeMap() { ); writeEnergyEvseInteractionInfo.put("writeApproximateEVEfficiencyAttribute", writeEnergyEvseApproximateEVEfficiencyAttributeInteractionInfo); writeAttributeMap.put("energyEvse", writeEnergyEvseInteractionInfo); - Map writeEnergyPreferenceInteractionInfo = new LinkedHashMap<>(); - Map writeEnergyPreferenceCurrentEnergyBalanceCommandParams = new LinkedHashMap(); - CommandParameterInfo energyPreferencecurrentEnergyBalanceCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeEnergyPreferenceCurrentEnergyBalanceCommandParams.put( - "value", - energyPreferencecurrentEnergyBalanceCommandParameterInfo - ); - InteractionInfo writeEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).writeCurrentEnergyBalanceAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeEnergyPreferenceCurrentEnergyBalanceCommandParams - ); - writeEnergyPreferenceInteractionInfo.put("writeCurrentEnergyBalanceAttribute", writeEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo); - Map writeEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams = new LinkedHashMap(); - CommandParameterInfo energyPreferencecurrentLowPowerModeSensitivityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams.put( - "value", - energyPreferencecurrentLowPowerModeSensitivityCommandParameterInfo - ); - InteractionInfo writeEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EnergyPreferenceCluster) cluster).writeCurrentLowPowerModeSensitivityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams - ); - writeEnergyPreferenceInteractionInfo.put("writeCurrentLowPowerModeSensitivityAttribute", writeEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo); - writeAttributeMap.put("energyPreference", writeEnergyPreferenceInteractionInfo); Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); Map writeDoorLockDoorOpenEventsCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockdoorOpenEventsCommandParameterInfo = diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt new file mode 100644 index 00000000000000..cf6ceebf5d48fd --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt @@ -0,0 +1,106 @@ +/* + * + * 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 OvenOperationalStateClusterOperationCompletionEvent( + val completionErrorCode: UInt, + val totalOperationalTime: Optional?, + val pausedTime: Optional? +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterOperationCompletionEvent {\n") + append("\tcompletionErrorCode : $completionErrorCode\n") + append("\ttotalOperationalTime : $totalOperationalTime\n") + append("\tpausedTime : $pausedTime\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE), completionErrorCode) + if (totalOperationalTime != null) { + if (totalOperationalTime.isPresent) { + val opttotalOperationalTime = totalOperationalTime.get() + put(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME), opttotalOperationalTime) + } + } else { + putNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) + } + if (pausedTime != null) { + if (pausedTime.isPresent) { + val optpausedTime = pausedTime.get() + put(ContextSpecificTag(TAG_PAUSED_TIME), optpausedTime) + } + } else { + putNull(ContextSpecificTag(TAG_PAUSED_TIME)) + } + endStructure() + } + } + + companion object { + private const val TAG_COMPLETION_ERROR_CODE = 0 + private const val TAG_TOTAL_OPERATIONAL_TIME = 1 + private const val TAG_PAUSED_TIME = 2 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): OvenOperationalStateClusterOperationCompletionEvent { + tlvReader.enterStructure(tlvTag) + val completionErrorCode = tlvReader.getUInt(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE)) + val totalOperationalTime = + if (!tlvReader.isNull()) { + if (tlvReader.isNextTag(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) { + Optional.of(tlvReader.getULong(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) + } else { + Optional.empty() + } + } else { + tlvReader.getNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) + null + } + val pausedTime = + if (!tlvReader.isNull()) { + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PAUSED_TIME))) { + Optional.of(tlvReader.getULong(ContextSpecificTag(TAG_PAUSED_TIME))) + } else { + Optional.empty() + } + } else { + tlvReader.getNull(ContextSpecificTag(TAG_PAUSED_TIME)) + null + } + + tlvReader.exitContainer() + + return OvenOperationalStateClusterOperationCompletionEvent( + completionErrorCode, + totalOperationalTime, + pausedTime + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt new file mode 100644 index 00000000000000..45252fa6422863 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt @@ -0,0 +1,61 @@ +/* + * + * 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 OvenOperationalStateClusterOperationalErrorEvent( + val errorState: chip.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterOperationalErrorEvent {\n") + append("\terrorState : $errorState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + errorState.toTlv(ContextSpecificTag(TAG_ERROR_STATE), this) + endStructure() + } + } + + companion object { + private const val TAG_ERROR_STATE = 0 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): OvenOperationalStateClusterOperationalErrorEvent { + tlvReader.enterStructure(tlvTag) + val errorState = + chip.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct.fromTlv( + ContextSpecificTag(TAG_ERROR_STATE), + tlvReader + ) + + tlvReader.exitContainer() + + return OvenOperationalStateClusterOperationalErrorEvent(errorState) + } + } +} 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 1cbd4a38983f5c..01d57d29c09e79 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni @@ -57,7 +57,6 @@ structs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ElectricalEnergyMeasurementClusterMeasurementAccuracyRangeStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ElectricalEnergyMeasurementClusterMeasurementAccuracyStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt", - "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyPreferenceClusterBalanceStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/FixedLabelClusterLabelStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/GeneralCommissioningClusterBasicCommissioningInfo.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/GeneralDiagnosticsClusterNetworkInterface.kt", diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt new file mode 100644 index 00000000000000..ffe36aeb938a8a --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt @@ -0,0 +1,85 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.structs + +import chip.devicecontroller.cluster.* +import java.util.Optional +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class OvenOperationalStateClusterErrorStateStruct( + val errorStateID: UInt, + val errorStateLabel: Optional, + val errorStateDetails: Optional +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterErrorStateStruct {\n") + append("\terrorStateID : $errorStateID\n") + append("\terrorStateLabel : $errorStateLabel\n") + append("\terrorStateDetails : $errorStateDetails\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_ERROR_STATE_I_D), errorStateID) + if (errorStateLabel.isPresent) { + val opterrorStateLabel = errorStateLabel.get() + put(ContextSpecificTag(TAG_ERROR_STATE_LABEL), opterrorStateLabel) + } + if (errorStateDetails.isPresent) { + val opterrorStateDetails = errorStateDetails.get() + put(ContextSpecificTag(TAG_ERROR_STATE_DETAILS), opterrorStateDetails) + } + endStructure() + } + } + + companion object { + private const val TAG_ERROR_STATE_I_D = 0 + private const val TAG_ERROR_STATE_LABEL = 1 + private const val TAG_ERROR_STATE_DETAILS = 2 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): OvenOperationalStateClusterErrorStateStruct { + tlvReader.enterStructure(tlvTag) + val errorStateID = tlvReader.getUInt(ContextSpecificTag(TAG_ERROR_STATE_I_D)) + val errorStateLabel = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) { + Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) + } else { + Optional.empty() + } + val errorStateDetails = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) { + Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) + } else { + Optional.empty() + } + + tlvReader.exitContainer() + + return OvenOperationalStateClusterErrorStateStruct( + errorStateID, + errorStateLabel, + errorStateDetails + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt new file mode 100644 index 00000000000000..1e68f9d3a6339c --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.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.structs + +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 OvenOperationalStateClusterOperationalStateStruct( + val operationalStateID: UInt, + val operationalStateLabel: Optional +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterOperationalStateStruct {\n") + append("\toperationalStateID : $operationalStateID\n") + append("\toperationalStateLabel : $operationalStateLabel\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D), operationalStateID) + if (operationalStateLabel.isPresent) { + val optoperationalStateLabel = operationalStateLabel.get() + put(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL), optoperationalStateLabel) + } + endStructure() + } + } + + companion object { + private const val TAG_OPERATIONAL_STATE_I_D = 0 + private const val TAG_OPERATIONAL_STATE_LABEL = 1 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): OvenOperationalStateClusterOperationalStateStruct { + tlvReader.enterStructure(tlvTag) + val operationalStateID = tlvReader.getUInt(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D)) + val operationalStateLabel = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) { + Optional.of(tlvReader.getString(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) + } else { + Optional.empty() + } + + tlvReader.exitContainer() + + return OvenOperationalStateClusterOperationalStateStruct( + operationalStateID, + operationalStateLabel + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt new file mode 100644 index 00000000000000..48ae3a43e7d850 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt @@ -0,0 +1,106 @@ +/* + * + * 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 OvenOperationalStateClusterOperationCompletionEvent( + val completionErrorCode: UInt, + val totalOperationalTime: Optional?, + val pausedTime: Optional? +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterOperationCompletionEvent {\n") + append("\tcompletionErrorCode : $completionErrorCode\n") + append("\ttotalOperationalTime : $totalOperationalTime\n") + append("\tpausedTime : $pausedTime\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE), completionErrorCode) + if (totalOperationalTime != null) { + if (totalOperationalTime.isPresent) { + val opttotalOperationalTime = totalOperationalTime.get() + put(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME), opttotalOperationalTime) + } + } else { + putNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) + } + if (pausedTime != null) { + if (pausedTime.isPresent) { + val optpausedTime = pausedTime.get() + put(ContextSpecificTag(TAG_PAUSED_TIME), optpausedTime) + } + } else { + putNull(ContextSpecificTag(TAG_PAUSED_TIME)) + } + endStructure() + } + } + + companion object { + private const val TAG_COMPLETION_ERROR_CODE = 0 + private const val TAG_TOTAL_OPERATIONAL_TIME = 1 + private const val TAG_PAUSED_TIME = 2 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): OvenOperationalStateClusterOperationCompletionEvent { + tlvReader.enterStructure(tlvTag) + val completionErrorCode = tlvReader.getUInt(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE)) + val totalOperationalTime = + if (!tlvReader.isNull()) { + if (tlvReader.isNextTag(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) + } else { + Optional.empty() + } + } else { + tlvReader.getNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) + null + } + val pausedTime = + if (!tlvReader.isNull()) { + if (tlvReader.isNextTag(ContextSpecificTag(TAG_PAUSED_TIME))) { + Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_PAUSED_TIME))) + } else { + Optional.empty() + } + } else { + tlvReader.getNull(ContextSpecificTag(TAG_PAUSED_TIME)) + null + } + + tlvReader.exitContainer() + + return OvenOperationalStateClusterOperationCompletionEvent( + completionErrorCode, + totalOperationalTime, + pausedTime + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt new file mode 100644 index 00000000000000..2a5615a137a44c --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt @@ -0,0 +1,62 @@ +/* + * + * 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 OvenOperationalStateClusterOperationalErrorEvent( + val errorState: + matter.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterOperationalErrorEvent {\n") + append("\terrorState : $errorState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + errorState.toTlv(ContextSpecificTag(TAG_ERROR_STATE), this) + endStructure() + } + } + + companion object { + private const val TAG_ERROR_STATE = 0 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): OvenOperationalStateClusterOperationalErrorEvent { + tlvReader.enterStructure(tlvTag) + val errorState = + matter.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct.fromTlv( + ContextSpecificTag(TAG_ERROR_STATE), + tlvReader + ) + + tlvReader.exitContainer() + + return OvenOperationalStateClusterOperationalErrorEvent(errorState) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt new file mode 100644 index 00000000000000..9c46796c30aab6 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt @@ -0,0 +1,85 @@ +/* + * + * 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.structs + +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 OvenOperationalStateClusterErrorStateStruct( + val errorStateID: UInt, + val errorStateLabel: Optional, + val errorStateDetails: Optional +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterErrorStateStruct {\n") + append("\terrorStateID : $errorStateID\n") + append("\terrorStateLabel : $errorStateLabel\n") + append("\terrorStateDetails : $errorStateDetails\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_ERROR_STATE_I_D), errorStateID) + if (errorStateLabel.isPresent) { + val opterrorStateLabel = errorStateLabel.get() + put(ContextSpecificTag(TAG_ERROR_STATE_LABEL), opterrorStateLabel) + } + if (errorStateDetails.isPresent) { + val opterrorStateDetails = errorStateDetails.get() + put(ContextSpecificTag(TAG_ERROR_STATE_DETAILS), opterrorStateDetails) + } + endStructure() + } + } + + companion object { + private const val TAG_ERROR_STATE_I_D = 0 + private const val TAG_ERROR_STATE_LABEL = 1 + private const val TAG_ERROR_STATE_DETAILS = 2 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): OvenOperationalStateClusterErrorStateStruct { + tlvReader.enterStructure(tlvTag) + val errorStateID = tlvReader.getUInt(ContextSpecificTag(TAG_ERROR_STATE_I_D)) + val errorStateLabel = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) { + Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) + } else { + Optional.empty() + } + val errorStateDetails = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) { + Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) + } else { + Optional.empty() + } + + tlvReader.exitContainer() + + return OvenOperationalStateClusterErrorStateStruct( + errorStateID, + errorStateLabel, + errorStateDetails + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt new file mode 100644 index 00000000000000..99fe7d6119c6f6 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.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.structs + +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 OvenOperationalStateClusterOperationalStateStruct( + val operationalStateID: UInt, + val operationalStateLabel: Optional +) { + override fun toString(): String = buildString { + append("OvenOperationalStateClusterOperationalStateStruct {\n") + append("\toperationalStateID : $operationalStateID\n") + append("\toperationalStateLabel : $operationalStateLabel\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D), operationalStateID) + if (operationalStateLabel.isPresent) { + val optoperationalStateLabel = operationalStateLabel.get() + put(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL), optoperationalStateLabel) + } + endStructure() + } + } + + companion object { + private const val TAG_OPERATIONAL_STATE_I_D = 0 + private const val TAG_OPERATIONAL_STATE_LABEL = 1 + + fun fromTlv( + tlvTag: Tag, + tlvReader: TlvReader + ): OvenOperationalStateClusterOperationalStateStruct { + tlvReader.enterStructure(tlvTag) + val operationalStateID = tlvReader.getUInt(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D)) + val operationalStateLabel = + if (tlvReader.isNextTag(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) { + Optional.of(tlvReader.getString(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) + } else { + Optional.empty() + } + + tlvReader.exitContainer() + + return OvenOperationalStateClusterOperationalStateStruct( + operationalStateID, + operationalStateLabel + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt new file mode 100644 index 00000000000000..d05e2591fb6ff2 --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt @@ -0,0 +1,211 @@ +/* + * + * 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 OvenOperationalStateCluster( + private val controller: MatterController, + private val endpointId: UShort +) { + class OperationalCommandResponse( + val commandResponseState: OvenOperationalStateClusterErrorStateStruct + ) + + class PhaseListAttribute(val value: List?) + + class CurrentPhaseAttribute(val value: UByte?) + + class CountdownTimeAttribute(val value: UInt?) + + class OperationalStateListAttribute( + val value: List + ) + + class OperationalErrorAttribute(val value: OvenOperationalStateClusterErrorStateStruct) + + class GeneratedCommandListAttribute(val value: List) + + class AcceptedCommandListAttribute(val value: List) + + class EventListAttribute(val value: List) + + class AttributeListAttribute(val value: List) + + suspend fun pause(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { + val commandId = 0L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun stop(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { + val commandId = 1L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun start(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { + val commandId = 2L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun resume(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { + val commandId = 3L + + if (timedInvokeTimeoutMs != null) { + // Do the action with timedInvokeTimeoutMs + } else { + // Do the action without timedInvokeTimeoutMs + } + } + + suspend fun readPhaseListAttribute(): PhaseListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribePhaseListAttribute(minInterval: Int, maxInterval: Int): PhaseListAttribute { + // Implementation needs to be added here + } + + suspend fun readCurrentPhaseAttribute(): CurrentPhaseAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeCurrentPhaseAttribute( + minInterval: Int, + maxInterval: Int + ): CurrentPhaseAttribute { + // Implementation needs to be added here + } + + suspend fun readCountdownTimeAttribute(): CountdownTimeAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeCountdownTimeAttribute( + minInterval: Int, + maxInterval: Int + ): CountdownTimeAttribute { + // Implementation needs to be added here + } + + suspend fun readOperationalStateListAttribute(): OperationalStateListAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeOperationalStateListAttribute( + minInterval: Int, + maxInterval: Int + ): OperationalStateListAttribute { + // Implementation needs to be added here + } + + suspend fun readOperationalStateAttribute(): UByte { + // Implementation needs to be added here + } + + suspend fun subscribeOperationalStateAttribute(minInterval: Int, maxInterval: Int): UByte { + // Implementation needs to be added here + } + + suspend fun readOperationalErrorAttribute(): OperationalErrorAttribute { + // Implementation needs to be added here + } + + suspend fun subscribeOperationalErrorAttribute( + minInterval: Int, + maxInterval: Int + ): OperationalErrorAttribute { + // 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 = 72u + } +} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni new file mode 100644 index 00000000000000..58232c1d089fa1 --- /dev/null +++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni @@ -0,0 +1,252 @@ +import("//build_overrides/build.gni") +import("//build_overrides/chip.gni") + +matter_structs_sources = [ + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AccessControlClusterAccessControlEntryStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AccessControlClusterAccessControlExtensionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AccessControlClusterAccessControlTargetStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ActionsClusterActionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ActionsClusterEndpointListStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ActivatedCarbonFilterMonitoringClusterReplacementProductStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ApplicationBasicClusterApplicationStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ApplicationLauncherClusterApplicationEPStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ApplicationLauncherClusterApplicationStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AudioOutputClusterOutputInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BasicInformationClusterCapabilityMinimaStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BasicInformationClusterProductAppearanceStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BindingClusterTargetStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BridgedDeviceBasicInformationClusterProductAppearanceStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ChannelClusterChannelInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ChannelClusterLineupInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterAdditionalInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterBrandingInformationStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterContentSearchStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterDimensionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterParameterStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterStyleInformationStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DescriptorClusterDeviceTypeStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DescriptorClusterSemanticTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DishwasherModeClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DishwasherModeClusterModeTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DoorLockClusterCredentialStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/FixedLabelClusterLabelStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GeneralCommissioningClusterBasicCommissioningInfo.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GeneralDiagnosticsClusterNetworkInterface.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GroupKeyManagementClusterGroupInfoMapStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GroupKeyManagementClusterGroupKeyMapStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GroupKeyManagementClusterGroupKeySetStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/HepaFilterMonitoringClusterReplacementProductStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/IcdManagementClusterMonitoringRegistrationStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/LaundryWasherModeClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/LaundryWasherModeClusterModeTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MediaInputClusterInputInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MediaPlaybackClusterPlaybackPositionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MicrowaveOvenModeClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MicrowaveOvenModeClusterModeTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ModeSelectClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ModeSelectClusterSemanticTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/NetworkCommissioningClusterNetworkInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/NetworkCommissioningClusterThreadInterfaceScanResultStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/NetworkCommissioningClusterWiFiInterfaceScanResultStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalCredentialsClusterFabricDescriptorStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalCredentialsClusterNOCStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalStateClusterErrorStateStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalStateClusterOperationalStateStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OtaSoftwareUpdateRequestorClusterProviderLocation.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/PowerSourceClusterBatChargeFaultChangeType.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/PowerSourceClusterBatFaultChangeType.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/PowerSourceClusterWiredFaultChangeType.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcCleanModeClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcCleanModeClusterModeTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcOperationalStateClusterErrorStateStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcOperationalStateClusterOperationalStateStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcRunModeClusterModeOptionStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcRunModeClusterModeTagStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ScenesClusterAttributeValuePair.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ScenesClusterExtensionFieldSet.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/SoftwareDiagnosticsClusterThreadMetricsStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TargetNavigatorClusterTargetInfoStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThermostatClusterThermostatScheduleTransition.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterNeighborTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterOperationalDatasetComponents.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterRouteTableStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterSecurityPolicy.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterDSTOffsetStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterTimeZoneStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterTrustedTimeSourceStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterDoubleNestedStructList.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterNestedStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterNestedStructList.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterNullablesAndOptionalsStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterSimpleStruct.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterTestFabricScoped.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterTestListStructOctet.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UserLabelClusterLabelStruct.kt", +] + +matter_eventstructs_sources = [ + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/AccessControlClusterAccessControlEntryChangedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/AccessControlClusterAccessControlExtensionChangedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ActionsClusterActionFailedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ActionsClusterStateChangedEvent.kt", + "${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/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", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DishwasherAlarmClusterNotifyEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterDoorLockAlarmEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterDoorStateChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationErrorEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockUserChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterBootReasonEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterHardwareFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterNetworkFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterRadioFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OperationalStateClusterOperationalErrorEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OperationalStateClusterOperationCompletionEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OtaSoftwareUpdateRequestorClusterDownloadErrorEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OtaSoftwareUpdateRequestorClusterStateTransitionEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OtaSoftwareUpdateRequestorClusterVersionAppliedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/PowerSourceClusterBatChargeFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/PowerSourceClusterBatFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/PowerSourceClusterWiredFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/RefrigeratorAlarmClusterNotifyEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/RvcOperationalStateClusterOperationalErrorEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/RvcOperationalStateClusterOperationCompletionEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterCOAlarmEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectCOAlarmEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectSmokeAlarmEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterLowBatteryEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterSmokeAlarmEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SoftwareDiagnosticsClusterSoftwareFaultEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterInitialPressEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterLongPressEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterLongReleaseEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterMultiPressCompleteEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterMultiPressOngoingEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterShortReleaseEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterSwitchLatchedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterConnectionStatusEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/TimeSynchronizationClusterDSTStatusEvent.kt", + "${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/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", +] + +matter_clusters_sources = [ + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AccessControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AccountLoginCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ActionsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ActivatedCarbonFilterMonitoringCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AdministratorCommissioningCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AirQualityCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ApplicationBasicCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ApplicationLauncherCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AudioOutputCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BallastConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BarrierControlCluster.kt", + "${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/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", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/CarbonMonoxideConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ChannelCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ColorControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ContentLauncherCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DescriptorCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DiagnosticLogsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DishwasherAlarmCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DishwasherModeCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DoorLockCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ElectricalMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EthernetNetworkDiagnosticsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FanControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FaultInjectionCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FixedLabelCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FlowMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FormaldehydeConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GeneralCommissioningCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GeneralDiagnosticsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GroupKeyManagementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GroupsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/HepaFilterMonitoringCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/IcdManagementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/IdentifyCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/IlluminanceMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/KeypadInputCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LaundryWasherControlsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LaundryWasherModeCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LevelControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LocalizationConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LowPowerCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MediaInputCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MediaPlaybackCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MicrowaveOvenControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MicrowaveOvenModeCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ModeSelectCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/NetworkCommissioningCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/NitrogenDioxideConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OccupancySensingCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OnOffCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OnOffSwitchConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OperationalCredentialsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OperationalStateCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OtaSoftwareUpdateProviderCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OtaSoftwareUpdateRequestorCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OzoneConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/Pm10ConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/Pm1ConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/Pm25ConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PowerSourceCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PowerSourceConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PressureMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ProxyConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ProxyDiscoveryCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ProxyValidCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PulseWidthModulationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PumpConfigurationAndControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RadonConcentrationMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RefrigeratorAlarmCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RefrigeratorAndTemperatureControlledCabinetModeCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RelativeHumidityMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RvcCleanModeCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RvcOperationalStateCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RvcRunModeCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SampleMeiCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ScenesCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SmokeCoAlarmCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SoftwareDiagnosticsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SwitchCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TargetNavigatorCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TemperatureControlCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TemperatureMeasurementCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ThermostatCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ThermostatUserInterfaceConfigurationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ThreadNetworkDiagnosticsCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TimeFormatLocalizationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TimeSynchronizationCluster.kt", + "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.kt", + "${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/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", +] \ No newline at end of file diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index 2dc5ac3303b7df..5785dc976dff93 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -5653,16 +5653,6 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } break; } - case app::Clusters::EnergyPreference::Id: { - using namespace app::Clusters::EnergyPreference; - switch (aPath.mEventId) - { - default: - *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; - break; - } - break; - } case app::Clusters::DoorLock::Id: { using namespace app::Clusters::DoorLock; switch (aPath.mEventId) diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index 2c5cfc50944076..de9f3606fff214 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -6985,82 +6985,6 @@ class ChipClusters: }, }, } - _ENERGY_PREFERENCE_CLUSTER_INFO = { - "clusterName": "EnergyPreference", - "clusterId": 0x0000009B, - "commands": { - }, - "attributes": { - 0x00000000: { - "attributeName": "EnergyBalances", - "attributeId": 0x00000000, - "type": "", - "reportable": True, - }, - 0x00000001: { - "attributeName": "CurrentEnergyBalance", - "attributeId": 0x00000001, - "type": "int", - "reportable": True, - "writable": True, - }, - 0x00000002: { - "attributeName": "EnergyPriorities", - "attributeId": 0x00000002, - "type": "int", - "reportable": True, - }, - 0x00000003: { - "attributeName": "LowPowerModeSensitivities", - "attributeId": 0x00000003, - "type": "", - "reportable": True, - }, - 0x00000004: { - "attributeName": "CurrentLowPowerModeSensitivity", - "attributeId": 0x00000004, - "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, - }, - }, - } _DOOR_LOCK_CLUSTER_INFO = { "clusterName": "DoorLock", "clusterId": 0x00000101, @@ -14199,7 +14123,6 @@ class ChipClusters: 0x00000096: _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO, 0x00000098: _DEVICE_ENERGY_MANAGEMENT_CLUSTER_INFO, 0x00000099: _ENERGY_EVSE_CLUSTER_INFO, - 0x0000009B: _ENERGY_PREFERENCE_CLUSTER_INFO, 0x00000101: _DOOR_LOCK_CLUSTER_INFO, 0x00000102: _WINDOW_COVERING_CLUSTER_INFO, 0x00000103: _BARRIER_CONTROL_CLUSTER_INFO, @@ -14315,7 +14238,6 @@ class ChipClusters: "DemandResponseLoadControl": _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO, "DeviceEnergyManagement": _DEVICE_ENERGY_MANAGEMENT_CLUSTER_INFO, "EnergyEvse": _ENERGY_EVSE_CLUSTER_INFO, - "EnergyPreference": _ENERGY_PREFERENCE_CLUSTER_INFO, "DoorLock": _DOOR_LOCK_CLUSTER_INFO, "WindowCovering": _WINDOW_COVERING_CLUSTER_INFO, "BarrierControl": _BARRIER_CONTROL_CLUSTER_INFO, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 6cfb1520eb2936..005038b5ac8230 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -24939,248 +24939,6 @@ def descriptor(cls) -> ClusterObjectDescriptor: uid: 'bytes' = b"" -@dataclass -class EnergyPreference(Cluster): - id: typing.ClassVar[int] = 0x0000009B - - @ChipUtility.classproperty - def descriptor(cls) -> ClusterObjectDescriptor: - return ClusterObjectDescriptor( - Fields=[ - ClusterObjectFieldDescriptor(Label="energyBalances", Tag=0x00000000, Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]), - ClusterObjectFieldDescriptor(Label="currentEnergyBalance", Tag=0x00000001, Type=typing.Optional[uint]), - ClusterObjectFieldDescriptor(Label="energyPriorities", Tag=0x00000002, Type=typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]), - ClusterObjectFieldDescriptor(Label="lowPowerModeSensitivities", Tag=0x00000003, Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]), - ClusterObjectFieldDescriptor(Label="currentLowPowerModeSensitivity", Tag=0x00000004, 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), - ]) - - energyBalances: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None - currentEnergyBalance: 'typing.Optional[uint]' = None - energyPriorities: 'typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]' = None - lowPowerModeSensitivities: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None - currentLowPowerModeSensitivity: '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 EnergyPriorityEnum(MatterIntEnum): - kComfort = 0x00 - kSpeed = 0x01 - kEfficiency = 0x02 - kWaterConsumption = 0x03 - # 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 = 4, - - class Bitmaps: - class Feature(IntFlag): - kEnergyBalance = 0x1 - kLowPowerModeSensitivity = 0x2 - - class Structs: - @dataclass - class BalanceStruct(ClusterObject): - @ChipUtility.classproperty - def descriptor(cls) -> ClusterObjectDescriptor: - return ClusterObjectDescriptor( - Fields=[ - ClusterObjectFieldDescriptor(Label="step", Tag=0, Type=uint), - ClusterObjectFieldDescriptor(Label="label", Tag=1, Type=typing.Optional[str]), - ]) - - step: 'uint' = 0 - label: 'typing.Optional[str]' = None - - class Attributes: - @dataclass - class EnergyBalances(ClusterAttributeDescriptor): - @ChipUtility.classproperty - def cluster_id(cls) -> int: - return 0x0000009B - - @ChipUtility.classproperty - def attribute_id(cls) -> int: - return 0x00000000 - - @ChipUtility.classproperty - def attribute_type(cls) -> ClusterObjectFieldDescriptor: - return ClusterObjectFieldDescriptor(Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]) - - value: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None - - @dataclass - class CurrentEnergyBalance(ClusterAttributeDescriptor): - @ChipUtility.classproperty - def cluster_id(cls) -> int: - return 0x0000009B - - @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 EnergyPriorities(ClusterAttributeDescriptor): - @ChipUtility.classproperty - def cluster_id(cls) -> int: - return 0x0000009B - - @ChipUtility.classproperty - def attribute_id(cls) -> int: - return 0x00000002 - - @ChipUtility.classproperty - def attribute_type(cls) -> ClusterObjectFieldDescriptor: - return ClusterObjectFieldDescriptor(Type=typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]) - - value: 'typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]' = None - - @dataclass - class LowPowerModeSensitivities(ClusterAttributeDescriptor): - @ChipUtility.classproperty - def cluster_id(cls) -> int: - return 0x0000009B - - @ChipUtility.classproperty - def attribute_id(cls) -> int: - return 0x00000003 - - @ChipUtility.classproperty - def attribute_type(cls) -> ClusterObjectFieldDescriptor: - return ClusterObjectFieldDescriptor(Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]) - - value: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None - - @dataclass - class CurrentLowPowerModeSensitivity(ClusterAttributeDescriptor): - @ChipUtility.classproperty - def cluster_id(cls) -> int: - return 0x0000009B - - @ChipUtility.classproperty - def attribute_id(cls) -> int: - return 0x00000004 - - @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 0x0000009B - - @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 0x0000009B - - @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 0x0000009B - - @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 0x0000009B - - @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 0x0000009B - - @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 0x0000009B - - @ChipUtility.classproperty - def attribute_id(cls) -> int: - return 0x0000FFFD - - @ChipUtility.classproperty - def attribute_type(cls) -> ClusterObjectFieldDescriptor: - return ClusterObjectFieldDescriptor(Type=uint) - - value: 'uint' = 0 - - @dataclass class DoorLock(Cluster): id: typing.ClassVar[int] = 0x00000101 diff --git a/src/controller/python/chip/clusters/__init__.py b/src/controller/python/chip/clusters/__init__.py index 9388432381ef69..aaf9da3cef301f 100644 --- a/src/controller/python/chip/clusters/__init__.py +++ b/src/controller/python/chip/clusters/__init__.py @@ -31,11 +31,18 @@ DoorLock, ElectricalMeasurement, EnergyEvse, EthernetNetworkDiagnostics, FanControl, FaultInjection, FixedLabel, FlowMeasurement, FormaldehydeConcentrationMeasurement, GeneralCommissioning, GeneralDiagnostics, GroupKeyManagement, Groups, HepaFilterMonitoring, IcdManagement, Identify, IlluminanceMeasurement, +<<<<<<< HEAD KeypadInput, LaundryDryerControls, LaundryWasherControls, LaundryWasherMode, LevelControl, LocalizationConfiguration, LowPower, MediaInput, MediaPlayback, MicrowaveOvenControl, MicrowaveOvenMode, ModeSelect, NetworkCommissioning, NitrogenDioxideConcentrationMeasurement, OccupancySensing, OnOff, OnOffSwitchConfiguration, OperationalCredentials, OperationalState, OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor, OvenCavityOperationalState, OvenMode, OzoneConcentrationMeasurement, +======= + KeypadInput, LaundryWasherControls, LaundryWasherMode, LevelControl, LocalizationConfiguration, LowPower, + MediaInput, MediaPlayback, ModeSelect, NetworkCommissioning, NitrogenDioxideConcentrationMeasurement, + OccupancySensing, OnOff, OnOffSwitchConfiguration, OperationalCredentials, OperationalState, + OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor, OvenCavityOperationalState, OzoneConcentrationMeasurement, +>>>>>>> 08e84a9c13 (Initial OpState work) Pm1ConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm25ConcentrationMeasurement, PowerSource, PowerSourceConfiguration, PressureMeasurement, ProxyConfiguration, ProxyDiscovery, ProxyValid, PulseWidthModulation, PumpConfigurationAndControl, RadonConcentrationMeasurement, RefrigeratorAlarm, @@ -59,7 +66,11 @@ LaundryWasherControls, LaundryWasherMode, LevelControl, LocalizationConfiguration, LowPower, MediaInput, MediaPlayback, MicrowaveOvenControl, MicrowaveOvenMode, ModeSelect, NetworkCommissioning, NitrogenDioxideConcentrationMeasurement, OccupancySensing, OnOff, OnOffSwitchConfiguration, OperationalCredentials, OperationalState, +<<<<<<< HEAD OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor, OvenCavityOperationalState, OvenMode, +======= + OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor,OvenCavityOperationalState, +>>>>>>> 08e84a9c13 (Initial OpState work) OzoneConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm25ConcentrationMeasurement, PowerSource, PowerSourceConfiguration, PressureMeasurement, ProxyConfiguration, ProxyDiscovery, ProxyValid, PulseWidthModulation, PumpConfigurationAndControl, RadonConcentrationMeasurement, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm index 61c99664562981..ecc5f5d7f80a47 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm @@ -3188,48 +3188,6 @@ static BOOL AttributeIsSpecifiedInEnergyEVSECluster(AttributeId aAttributeId) } } } -static BOOL AttributeIsSpecifiedInEnergyPreferenceCluster(AttributeId aAttributeId) -{ - using namespace Clusters::EnergyPreference; - switch (aAttributeId) { - case Attributes::EnergyBalances::Id: { - return YES; - } - case Attributes::CurrentEnergyBalance::Id: { - return YES; - } - case Attributes::EnergyPriorities::Id: { - return YES; - } - case Attributes::LowPowerModeSensitivities::Id: { - return YES; - } - case Attributes::CurrentLowPowerModeSensitivity::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 AttributeIsSpecifiedInDoorLockCluster(AttributeId aAttributeId) { using namespace Clusters::DoorLock; @@ -6501,9 +6459,6 @@ BOOL MTRAttributeIsSpecified(ClusterId aClusterId, AttributeId aAttributeId) case Clusters::EnergyEvse::Id: { return AttributeIsSpecifiedInEnergyEVSECluster(aAttributeId); } - case Clusters::EnergyPreference::Id: { - return AttributeIsSpecifiedInEnergyPreferenceCluster(aAttributeId); - } case Clusters::DoorLock::Id: { return AttributeIsSpecifiedInDoorLockCluster(aAttributeId); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm index 6308eacacf72f9..588e4a533c503c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm @@ -8894,140 +8894,6 @@ static id _Nullable DecodeAttributeValueForEnergyEVSECluster(AttributeId aAttrib *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; return nil; } -static id _Nullable DecodeAttributeValueForEnergyPreferenceCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) -{ - using namespace Clusters::EnergyPreference; - switch (aAttributeId) { - case Attributes::EnergyBalances::Id: { - using TypeInfo = Attributes::EnergyBalances::TypeInfo; - TypeInfo::DecodableType cppValue; - *aError = DataModel::Decode(aReader, cppValue); - if (*aError != CHIP_NO_ERROR) { - return nil; - } - NSArray * _Nonnull value; - { // Scope for our temporary variables - auto * array_0 = [NSMutableArray new]; - auto iter_0 = cppValue.begin(); - while (iter_0.Next()) { - auto & entry_0 = iter_0.GetValue(); - MTREnergyPreferenceClusterBalanceStruct * newElement_0; - newElement_0 = [MTREnergyPreferenceClusterBalanceStruct new]; - newElement_0.step = [NSNumber numberWithUnsignedChar:entry_0.step]; - if (entry_0.label.HasValue()) { - newElement_0.label = AsString(entry_0.label.Value()); - if (newElement_0.label == nil) { - CHIP_ERROR err = CHIP_ERROR_INVALID_ARGUMENT; - *aError = err; - return nil; - } - } else { - newElement_0.label = nil; - } - [array_0 addObject:newElement_0]; - } - CHIP_ERROR err = iter_0.GetStatus(); - if (err != CHIP_NO_ERROR) { - *aError = err; - return nil; - } - value = array_0; - } - return value; - } - case Attributes::CurrentEnergyBalance::Id: { - using TypeInfo = Attributes::CurrentEnergyBalance::TypeInfo; - TypeInfo::DecodableType cppValue; - *aError = DataModel::Decode(aReader, cppValue); - if (*aError != CHIP_NO_ERROR) { - return nil; - } - NSNumber * _Nonnull value; - value = [NSNumber numberWithUnsignedChar:cppValue]; - return value; - } - case Attributes::EnergyPriorities::Id: { - using TypeInfo = Attributes::EnergyPriorities::TypeInfo; - TypeInfo::DecodableType cppValue; - *aError = DataModel::Decode(aReader, cppValue); - if (*aError != CHIP_NO_ERROR) { - return nil; - } - NSArray * _Nonnull value; - { // Scope for our temporary variables - auto * array_0 = [NSMutableArray new]; - auto iter_0 = cppValue.begin(); - while (iter_0.Next()) { - auto & entry_0 = iter_0.GetValue(); - NSNumber * newElement_0; - newElement_0 = [NSNumber numberWithUnsignedChar:chip::to_underlying(entry_0)]; - [array_0 addObject:newElement_0]; - } - CHIP_ERROR err = iter_0.GetStatus(); - if (err != CHIP_NO_ERROR) { - *aError = err; - return nil; - } - value = array_0; - } - return value; - } - case Attributes::LowPowerModeSensitivities::Id: { - using TypeInfo = Attributes::LowPowerModeSensitivities::TypeInfo; - TypeInfo::DecodableType cppValue; - *aError = DataModel::Decode(aReader, cppValue); - if (*aError != CHIP_NO_ERROR) { - return nil; - } - NSArray * _Nonnull value; - { // Scope for our temporary variables - auto * array_0 = [NSMutableArray new]; - auto iter_0 = cppValue.begin(); - while (iter_0.Next()) { - auto & entry_0 = iter_0.GetValue(); - MTREnergyPreferenceClusterBalanceStruct * newElement_0; - newElement_0 = [MTREnergyPreferenceClusterBalanceStruct new]; - newElement_0.step = [NSNumber numberWithUnsignedChar:entry_0.step]; - if (entry_0.label.HasValue()) { - newElement_0.label = AsString(entry_0.label.Value()); - if (newElement_0.label == nil) { - CHIP_ERROR err = CHIP_ERROR_INVALID_ARGUMENT; - *aError = err; - return nil; - } - } else { - newElement_0.label = nil; - } - [array_0 addObject:newElement_0]; - } - CHIP_ERROR err = iter_0.GetStatus(); - if (err != CHIP_NO_ERROR) { - *aError = err; - return nil; - } - value = array_0; - } - return value; - } - case Attributes::CurrentLowPowerModeSensitivity::Id: { - using TypeInfo = Attributes::CurrentLowPowerModeSensitivity::TypeInfo; - TypeInfo::DecodableType cppValue; - *aError = DataModel::Decode(aReader, cppValue); - if (*aError != CHIP_NO_ERROR) { - return nil; - } - NSNumber * _Nonnull value; - value = [NSNumber numberWithUnsignedChar:cppValue]; - return value; - } - default: { - break; - } - } - - *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; - return nil; -} static id _Nullable DecodeAttributeValueForDoorLockCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::DoorLock; @@ -18675,9 +18541,6 @@ id _Nullable MTRDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::T case Clusters::EnergyEvse::Id: { return DecodeAttributeValueForEnergyEVSECluster(aPath.mAttributeId, aReader, aError); } - case Clusters::EnergyPreference::Id: { - return DecodeAttributeValueForEnergyPreferenceCluster(aPath.mAttributeId, aReader, aError); - } case Clusters::DoorLock::Id: { return DecodeAttributeValueForDoorLockCluster(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 1c3298fb15b308..bbf56e5bb8601c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -7945,101 +7945,6 @@ MTR_PROVISIONALLY_AVAILABLE @end -/** - * Cluster Energy Preference - * - * This cluster provides an interface to specify preferences for how devices should consume energy. - */ -MTR_PROVISIONALLY_AVAILABLE -@interface MTRBaseClusterEnergyPreference : MTRGenericBaseCluster - -- (void)readAttributeEnergyBalancesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; -- (void)subscribeAttributeEnergyBalancesWithParams:(MTRSubscribeParams *)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; -+ (void)readAttributeEnergyBalancesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; - -- (void)readAttributeCurrentEnergyBalanceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; -- (void)subscribeAttributeCurrentEnergyBalanceWithParams:(MTRSubscribeParams *)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; -+ (void)readAttributeCurrentEnergyBalanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; - -- (void)readAttributeEnergyPrioritiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; -- (void)subscribeAttributeEnergyPrioritiesWithParams:(MTRSubscribeParams *)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; -+ (void)readAttributeEnergyPrioritiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; - -- (void)readAttributeLowPowerModeSensitivitiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; -- (void)subscribeAttributeLowPowerModeSensitivitiesWithParams:(MTRSubscribeParams *)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; -+ (void)readAttributeLowPowerModeSensitivitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; - -- (void)readAttributeCurrentLowPowerModeSensitivityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; -- (void)subscribeAttributeCurrentLowPowerModeSensitivityWithParams:(MTRSubscribeParams *)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; -+ (void)readAttributeCurrentLowPowerModeSensitivityWithClusterStateCache:(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 MTRBaseClusterEnergyPreference (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 Door Lock * @@ -17468,18 +17373,6 @@ typedef NS_OPTIONS(uint8_t, MTREnergyEVSETargetDayOfWeekBitmap) { MTREnergyEVSETargetDayOfWeekBitmapSaturday MTR_PROVISIONALLY_AVAILABLE = 0x40, } MTR_PROVISIONALLY_AVAILABLE; -typedef NS_ENUM(uint8_t, MTREnergyPreferenceEnergyPriority) { - MTREnergyPreferenceEnergyPriorityComfort MTR_PROVISIONALLY_AVAILABLE = 0x00, - MTREnergyPreferenceEnergyPrioritySpeed MTR_PROVISIONALLY_AVAILABLE = 0x01, - MTREnergyPreferenceEnergyPriorityEfficiency MTR_PROVISIONALLY_AVAILABLE = 0x02, - MTREnergyPreferenceEnergyPriorityWaterConsumption MTR_PROVISIONALLY_AVAILABLE = 0x03, -} MTR_PROVISIONALLY_AVAILABLE; - -typedef NS_OPTIONS(uint32_t, MTREnergyPreferenceFeature) { - MTREnergyPreferenceFeatureEnergyBalance MTR_PROVISIONALLY_AVAILABLE = 0x1, - MTREnergyPreferenceFeatureLowPowerModeSensitivity MTR_PROVISIONALLY_AVAILABLE = 0x2, -} MTR_PROVISIONALLY_AVAILABLE; - typedef NS_ENUM(uint8_t, MTRDoorLockAlarmCode) { MTRDoorLockAlarmCodeLockJammed MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00, MTRDoorLockAlarmCodeLockFactoryReset MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x01, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm index 1bda7cb36cd7bf..3d4fb9799ca6a6 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm @@ -53268,462 +53268,6 @@ + (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheC @end -@implementation MTRBaseClusterEnergyPreference - -- (void)readAttributeEnergyBalancesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo; - [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:nil - queue:self.callbackQueue - completion:completion]; -} - -- (void)subscribeAttributeEnergyBalancesWithParams:(MTRSubscribeParams * _Nonnull)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler -{ - using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo; - [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:params - queue:self.callbackQueue - reportHandler:reportHandler - subscriptionEstablished:subscriptionEstablished]; -} - -+ (void)readAttributeEnergyBalancesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo; - [clusterStateCacheContainer - _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) - clusterID:TypeInfo::GetClusterId() - attributeID:TypeInfo::GetAttributeId() - queue:queue - completion:completion]; -} - -- (void)readAttributeCurrentEnergyBalanceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; - [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:nil - queue:self.callbackQueue - completion:completion]; -} - -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion -{ - [self writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; -} -- (void)writeAttributeCurrentEnergyBalanceWithValue:(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 = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; - TypeInfo::Type cppValue; - cppValue = 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)subscribeAttributeCurrentEnergyBalanceWithParams:(MTRSubscribeParams * _Nonnull)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler -{ - using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; - [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:params - queue:self.callbackQueue - reportHandler:reportHandler - subscriptionEstablished:subscriptionEstablished]; -} - -+ (void)readAttributeCurrentEnergyBalanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; - [clusterStateCacheContainer - _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) - clusterID:TypeInfo::GetClusterId() - attributeID:TypeInfo::GetAttributeId() - queue:queue - completion:completion]; -} - -- (void)readAttributeEnergyPrioritiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo; - [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:nil - queue:self.callbackQueue - completion:completion]; -} - -- (void)subscribeAttributeEnergyPrioritiesWithParams:(MTRSubscribeParams * _Nonnull)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler -{ - using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo; - [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:params - queue:self.callbackQueue - reportHandler:reportHandler - subscriptionEstablished:subscriptionEstablished]; -} - -+ (void)readAttributeEnergyPrioritiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo; - [clusterStateCacheContainer - _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) - clusterID:TypeInfo::GetClusterId() - attributeID:TypeInfo::GetAttributeId() - queue:queue - completion:completion]; -} - -- (void)readAttributeLowPowerModeSensitivitiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo; - [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:nil - queue:self.callbackQueue - completion:completion]; -} - -- (void)subscribeAttributeLowPowerModeSensitivitiesWithParams:(MTRSubscribeParams * _Nonnull)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler -{ - using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo; - [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:params - queue:self.callbackQueue - reportHandler:reportHandler - subscriptionEstablished:subscriptionEstablished]; -} - -+ (void)readAttributeLowPowerModeSensitivitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo; - [clusterStateCacheContainer - _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) - clusterID:TypeInfo::GetClusterId() - attributeID:TypeInfo::GetAttributeId() - queue:queue - completion:completion]; -} - -- (void)readAttributeCurrentLowPowerModeSensitivityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo; - [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:nil - queue:self.callbackQueue - completion:completion]; -} - -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion -{ - [self writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; -} -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(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 = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo; - TypeInfo::Type cppValue; - cppValue = 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)subscribeAttributeCurrentLowPowerModeSensitivityWithParams:(MTRSubscribeParams * _Nonnull)params - subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished - reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler -{ - using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo; - [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) - clusterID:@(TypeInfo::GetClusterId()) - attributeID:@(TypeInfo::GetAttributeId()) - params:params - queue:self.callbackQueue - reportHandler:reportHandler - subscriptionEstablished:subscriptionEstablished]; -} - -+ (void)readAttributeCurrentLowPowerModeSensitivityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion -{ - using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::Attributes::ClusterRevision::TypeInfo; - [clusterStateCacheContainer - _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) - clusterID:TypeInfo::GetClusterId() - attributeID:TypeInfo::GetAttributeId() - queue:queue - completion:completion]; -} - -@end - @implementation MTRBaseClusterDoorLock - (void)lockDoorWithCompletion:(MTRStatusCompletion)completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 77e169df653784..aebafa0f07b881 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -153,7 +153,6 @@ typedef NS_ENUM(uint32_t, MTRClusterIDType) { MTRClusterIDTypeDemandResponseLoadControlID MTR_PROVISIONALLY_AVAILABLE = 0x00000096, MTRClusterIDTypeDeviceEnergyManagementID MTR_PROVISIONALLY_AVAILABLE = 0x00000098, MTRClusterIDTypeEnergyEVSEID MTR_PROVISIONALLY_AVAILABLE = 0x00000099, - MTRClusterIDTypeEnergyPreferenceID MTR_PROVISIONALLY_AVAILABLE = 0x0000009B, 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, MTRClusterIDTypeBarrierControlID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000103, @@ -2658,19 +2657,6 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterEnergyEVSEAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, MTRAttributeIDTypeClusterEnergyEVSEAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, - // Cluster EnergyPreference attributes - MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyBalancesID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentEnergyBalanceID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyPrioritiesID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeLowPowerModeSensitivitiesID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentLowPowerModeSensitivityID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeEventListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeEventListID, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, - MTRAttributeIDTypeClusterEnergyPreferenceAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, - // Cluster DoorLock deprecated attribute names MTRClusterDoorLockAttributeLockStateID MTR_DEPRECATED("Please use MTRAttributeIDTypeClusterDoorLockAttributeLockStateID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h index 6fcea80c35673e..e16555ac8d65f8 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h @@ -3730,56 +3730,6 @@ MTR_PROVISIONALLY_AVAILABLE @end -/** - * Cluster Energy Preference - * This cluster provides an interface to specify preferences for how devices should consume energy. - */ -MTR_PROVISIONALLY_AVAILABLE -@interface MTRClusterEnergyPreference : MTRGenericCluster - -- (NSDictionary * _Nullable)readAttributeEnergyBalancesWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; - -- (NSDictionary * _Nullable)readAttributeCurrentEnergyBalanceWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; - -- (NSDictionary * _Nullable)readAttributeEnergyPrioritiesWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; - -- (NSDictionary * _Nullable)readAttributeLowPowerModeSensitivitiesWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; - -- (NSDictionary * _Nullable)readAttributeCurrentLowPowerModeSensitivityWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(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 MTRClusterEnergyPreference (Availability) - -/** - * The queue is currently unused, but may be used in the future for calling completions - * for command invocations if commands are added to this cluster. - */ -- (instancetype _Nullable)initWithDevice:(MTRDevice *)device - endpointID:(NSNumber *)endpointID - queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; - -@end - /** * Cluster Door Lock * An interface to a generic way to secure a door diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm index 7f79d6452d3415..0ba4c0c9a54202 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm @@ -10185,87 +10185,6 @@ - (void)writeAttributeApproximateEVEfficiencyWithValue:(NSDictionary * _Nullable)readAttributeEnergyBalancesWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyBalancesID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeCurrentEnergyBalanceWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentEnergyBalanceID) params:params]; -} - -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs -{ - [self writeAttributeCurrentEnergyBalanceWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; -} -- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params -{ - NSNumber * timedWriteTimeout = params.timedWriteTimeout; - - [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentEnergyBalanceID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; -} - -- (NSDictionary * _Nullable)readAttributeEnergyPrioritiesWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyPrioritiesID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeLowPowerModeSensitivitiesWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeLowPowerModeSensitivitiesID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeCurrentLowPowerModeSensitivityWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentLowPowerModeSensitivityID) params:params]; -} - -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs -{ - [self writeAttributeCurrentLowPowerModeSensitivityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; -} -- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params -{ - NSNumber * timedWriteTimeout = params.timedWriteTimeout; - - [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentLowPowerModeSensitivityID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; -} - -- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeGeneratedCommandListID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeAcceptedCommandListID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeEventListID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeAttributeListID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeFeatureMapID) params:params]; -} - -- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params -{ - return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeClusterRevisionID) params:params]; -} - -@end - @implementation MTRClusterDoorLock - (void)lockDoorWithExpectedValues:(NSArray *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(MTRStatusCompletion)completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm index caa80fba219adb..6cd8d96b3a2745 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm @@ -647,15 +647,6 @@ static BOOL CommandNeedsTimedInvokeInEnergyEVSECluster(AttributeId aAttributeId) } } } -static BOOL CommandNeedsTimedInvokeInEnergyPreferenceCluster(AttributeId aAttributeId) -{ - using namespace Clusters::EnergyPreference; - switch (aAttributeId) { - default: { - return NO; - } - } -} static BOOL CommandNeedsTimedInvokeInDoorLockCluster(AttributeId aAttributeId) { using namespace Clusters::DoorLock; @@ -1281,9 +1272,6 @@ BOOL MTRCommandNeedsTimedInvoke(NSNumber * _Nonnull aClusterID, NSNumber * _Nonn case Clusters::EnergyEvse::Id: { return CommandNeedsTimedInvokeInEnergyEVSECluster(commandID); } - case Clusters::EnergyPreference::Id: { - return CommandNeedsTimedInvokeInEnergyPreferenceCluster(commandID); - } case Clusters::DoorLock::Id: { return CommandNeedsTimedInvokeInDoorLockCluster(commandID); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index 119031161f5195..d7c1b50249a15d 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -3055,18 +3055,6 @@ static id _Nullable DecodeEventPayloadForEnergyEVSECluster(EventId aEventId, TLV *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; return nil; } -static id _Nullable DecodeEventPayloadForEnergyPreferenceCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) -{ - using namespace Clusters::EnergyPreference; - switch (aEventId) { - default: { - break; - } - } - - *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; - return nil; -} static id _Nullable DecodeEventPayloadForDoorLockCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::DoorLock; @@ -4505,9 +4493,6 @@ id _Nullable MTRDecodeEventPayload(const ConcreteEventPath & aPath, TLV::TLVRead case Clusters::EnergyEvse::Id: { return DecodeEventPayloadForEnergyEVSECluster(aPath.mEventId, aReader, aError); } - case Clusters::EnergyPreference::Id: { - return DecodeEventPayloadForEnergyPreferenceCluster(aPath.mEventId, aReader, aError); - } case Clusters::DoorLock::Id: { return DecodeEventPayloadForDoorLockCluster(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 064bd1f321d21e..820242a59f0acd 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1325,12 +1325,6 @@ MTR_PROVISIONALLY_AVAILABLE @property (nonatomic, copy) NSData * _Nonnull uid MTR_PROVISIONALLY_AVAILABLE; @end -MTR_PROVISIONALLY_AVAILABLE -@interface MTREnergyPreferenceClusterBalanceStruct : NSObject -@property (nonatomic, copy) NSNumber * _Nonnull step MTR_PROVISIONALLY_AVAILABLE; -@property (nonatomic, copy) NSString * _Nullable label MTR_PROVISIONALLY_AVAILABLE; -@end - MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) @interface MTRDoorLockClusterCredentialStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull credentialType MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)); diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index d8b97ec82d42fa..14a259b78baecb 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -5439,36 +5439,6 @@ - (NSString *)description @end -@implementation MTREnergyPreferenceClusterBalanceStruct -- (instancetype)init -{ - if (self = [super init]) { - - _step = @(0); - - _label = nil; - } - return self; -} - -- (id)copyWithZone:(NSZone * _Nullable)zone -{ - auto other = [[MTREnergyPreferenceClusterBalanceStruct alloc] init]; - - other.step = self.step; - other.label = self.label; - - return other; -} - -- (NSString *)description -{ - NSString * descriptionString = [NSString stringWithFormat:@"<%@: step:%@; label:%@; >", NSStringFromClass([self class]), _step, _label]; - return descriptionString; -} - -@end - @implementation MTRDoorLockClusterCredentialStruct - (instancetype)init { diff --git a/third_party/imgui/repo b/third_party/imgui/repo index 6228c2e1ec7ef2..240ab5890b2e8d 160000 --- a/third_party/imgui/repo +++ b/third_party/imgui/repo @@ -1 +1 @@ -Subproject commit 6228c2e1ec7ef21ca1809579c055ed34540dedb0 +Subproject commit 240ab5890b2e8da294937a1710b021ac3f271472 diff --git a/third_party/libwebsockets/repo b/third_party/libwebsockets/repo index 49bfef2ecd51b8..f18fc2316f9743 160000 --- a/third_party/libwebsockets/repo +++ b/third_party/libwebsockets/repo @@ -1 +1 @@ -Subproject commit 49bfef2ecd51b854b63e35d913849b6bb518a7f6 +Subproject commit f18fc2316f9743624ced9ba934595f7b9ba8cd05 diff --git a/third_party/mbedtls/repo b/third_party/mbedtls/repo index 56fd26cee97531..ffb18d2012909c 160000 --- a/third_party/mbedtls/repo +++ b/third_party/mbedtls/repo @@ -1 +1 @@ -Subproject commit 56fd26cee97531f223071b91ed108dc1e22e7a85 +Subproject commit ffb18d2012909c05277a1e16dc6ba23dc8ba2854 diff --git a/third_party/nanopb/repo b/third_party/nanopb/repo index 423c03b626a861..cf26d28b88010d 160000 --- a/third_party/nanopb/repo +++ b/third_party/nanopb/repo @@ -1 +1 @@ -Subproject commit 423c03b626a861a7b3a08a2d411e23aefd58827b +Subproject commit cf26d28b88010dd3ac94e0cba64d4a71522154bc diff --git a/third_party/openthread/repo b/third_party/openthread/repo index f1e74a036b5bd2..d81c6fab98df8f 160000 --- a/third_party/openthread/repo +++ b/third_party/openthread/repo @@ -1 +1 @@ -Subproject commit f1e74a036b5bd2e9dd6565161ab806cc854dc0b4 +Subproject commit d81c6fab98df8fbeb0f3611ce5ec4c131c84cbce diff --git a/third_party/ot-br-posix/repo b/third_party/ot-br-posix/repo index 58822dce193456..657e775cd9ca75 160000 --- a/third_party/ot-br-posix/repo +++ b/third_party/ot-br-posix/repo @@ -1 +1 @@ -Subproject commit 58822dce1934568523bf1389c039f249e1d979ad +Subproject commit 657e775cd9ca757af7487da2fb039aee645c3d65 diff --git a/third_party/pigweed/repo b/third_party/pigweed/repo index 9640cdef100f87..cbbc73dc4d56bc 160000 --- a/third_party/pigweed/repo +++ b/third_party/pigweed/repo @@ -1 +1 @@ -Subproject commit 9640cdef100f87d7987875d3a418931d6500e5b2 +Subproject commit cbbc73dc4d56bc201e9d50c4b10db974aff82754 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 6f3fba5935f84d..49d7459ace3f94 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 @@ -10533,136 +10533,6 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) } // namespace Attributes } // namespace EnergyEvse -namespace EnergyPreference { -namespace Attributes { - -namespace CurrentEnergyBalance { - -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType temp; - uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); - EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::EnergyPreference::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, uint8_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::EnergyPreference::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); -} - -} // namespace CurrentEnergyBalance - -namespace CurrentLowPowerModeSensitivity { - -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType temp; - uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); - EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::EnergyPreference::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, uint8_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::EnergyPreference::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); -} - -} // namespace CurrentLowPowerModeSensitivity - -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::EnergyPreference::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::EnergyPreference::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::EnergyPreference::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::EnergyPreference::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); -} - -} // namespace ClusterRevision - -} // namespace Attributes -} // namespace EnergyPreference - namespace DoorLock { 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 2fed842607a66e..d30e7984a405ec 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 @@ -2051,32 +2051,6 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Attributes } // namespace EnergyEvse -namespace EnergyPreference { -namespace Attributes { - -namespace CurrentEnergyBalance { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u -EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); -} // namespace CurrentEnergyBalance - -namespace CurrentLowPowerModeSensitivity { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u -EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); -} // namespace CurrentLowPowerModeSensitivity - -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 EnergyPreference - namespace DoorLock { namespace Attributes { 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 fa83804118b175..a76ef9430a3dc6 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 @@ -1784,21 +1784,6 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyEvse::SupplyState } } -static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyPreference::EnergyPriorityEnum val) -{ - using EnumType = EnergyPreference::EnergyPriorityEnum; - switch (val) - { - case EnumType::kComfort: - case EnumType::kSpeed: - case EnumType::kEfficiency: - case EnumType::kWaterConsumption: - return val; - default: - return static_cast(4); - } -} - static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::AlarmCodeEnum val) { using EnumType = DoorLock::AlarmCodeEnum; 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 49b66ec661f0eb..1931a6680fffa3 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 @@ -2556,30 +2556,6 @@ enum class TargetDayOfWeekBitmap : uint8_t }; } // namespace EnergyEvse -namespace EnergyPreference { - -// Enum for EnergyPriorityEnum -enum class EnergyPriorityEnum : uint8_t -{ - kComfort = 0x00, - kSpeed = 0x01, - kEfficiency = 0x02, - kWaterConsumption = 0x03, - // 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 = 4, -}; - -// Bitmap for Feature -enum class Feature : uint32_t -{ - kEnergyBalance = 0x1, - kLowPowerModeSensitivity = 0x2, -}; -} // namespace EnergyPreference - namespace DoorLock { // Enum for AlarmCodeEnum 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 e4988fdd696cd1..7603d5c18e39e1 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 @@ -16482,89 +16482,6 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Events } // namespace EnergyEvse -namespace EnergyPreference { -namespace Structs { - -namespace BalanceStruct { -CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const -{ - DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; - encoder.Encode(to_underlying(Fields::kStep), step); - encoder.Encode(to_underlying(Fields::kLabel), label); - 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::kStep)) - { - err = DataModel::Decode(reader, step); - } - else if (__context_tag == to_underlying(Fields::kLabel)) - { - err = DataModel::Decode(reader, label); - } - else - { - } - - ReturnErrorOnFailure(err); - } -} - -} // namespace BalanceStruct -} // namespace Structs - -namespace Commands {} // namespace Commands - -namespace Attributes { -CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) -{ - switch (path.mAttributeId) - { - case Attributes::EnergyBalances::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, energyBalances); - case Attributes::CurrentEnergyBalance::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, currentEnergyBalance); - case Attributes::EnergyPriorities::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, energyPriorities); - case Attributes::LowPowerModeSensitivities::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, lowPowerModeSensitivities); - case Attributes::CurrentLowPowerModeSensitivity::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, currentLowPowerModeSensitivity); - case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, generatedCommandList); - case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, acceptedCommandList); - case Attributes::EventList::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, eventList); - case Attributes::AttributeList::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, attributeList); - case Attributes::FeatureMap::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, featureMap); - case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): - return DataModel::Decode(reader, clusterRevision); - default: - return CHIP_NO_ERROR; - } -} -} // namespace Attributes - -namespace Events {} // namespace Events - -} // namespace EnergyPreference namespace DoorLock { namespace Structs { 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 e41a226edfbdaa..be53c43d05a1a6 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 @@ -22993,160 +22993,6 @@ struct DecodableType } // namespace Rfid } // namespace Events } // namespace EnergyEvse -namespace EnergyPreference { -namespace Structs { -namespace BalanceStruct { -enum class Fields : uint8_t -{ - kStep = 0, - kLabel = 1, -}; - -struct Type -{ -public: - chip::Percent step = static_cast(0); - Optional label; - - CHIP_ERROR Decode(TLV::TLVReader & reader); - - static constexpr bool kIsFabricScoped = false; - - CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; -}; - -using DecodableType = Type; - -} // namespace BalanceStruct -} // namespace Structs - -namespace Attributes { - -namespace EnergyBalances { -struct TypeInfo -{ - using Type = chip::app::DataModel::List; - using DecodableType = - chip::app::DataModel::DecodableList; - using DecodableArgType = - const chip::app::DataModel::DecodableList &; - - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::EnergyBalances::Id; } - static constexpr bool MustUseTimedWrite() { return false; } -}; -} // namespace EnergyBalances -namespace CurrentEnergyBalance { -struct TypeInfo -{ - using Type = uint8_t; - using DecodableType = uint8_t; - using DecodableArgType = uint8_t; - - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::CurrentEnergyBalance::Id; } - static constexpr bool MustUseTimedWrite() { return false; } -}; -} // namespace CurrentEnergyBalance -namespace EnergyPriorities { -struct TypeInfo -{ - using Type = chip::app::DataModel::List; - using DecodableType = chip::app::DataModel::DecodableList; - using DecodableArgType = const chip::app::DataModel::DecodableList &; - - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::EnergyPriorities::Id; } - static constexpr bool MustUseTimedWrite() { return false; } -}; -} // namespace EnergyPriorities -namespace LowPowerModeSensitivities { -struct TypeInfo -{ - using Type = chip::app::DataModel::List; - using DecodableType = - chip::app::DataModel::DecodableList; - using DecodableArgType = - const chip::app::DataModel::DecodableList &; - - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::LowPowerModeSensitivities::Id; } - static constexpr bool MustUseTimedWrite() { return false; } -}; -} // namespace LowPowerModeSensitivities -namespace CurrentLowPowerModeSensitivity { -struct TypeInfo -{ - using Type = uint8_t; - using DecodableType = uint8_t; - using DecodableArgType = uint8_t; - - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } - static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLowPowerModeSensitivity::Id; } - static constexpr bool MustUseTimedWrite() { return false; } -}; -} // namespace CurrentLowPowerModeSensitivity -namespace GeneratedCommandList { -struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo -{ - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } -}; -} // namespace GeneratedCommandList -namespace AcceptedCommandList { -struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo -{ - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } -}; -} // namespace AcceptedCommandList -namespace EventList { -struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo -{ - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } -}; -} // namespace EventList -namespace AttributeList { -struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo -{ - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } -}; -} // namespace AttributeList -namespace FeatureMap { -struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo -{ - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } -}; -} // namespace FeatureMap -namespace ClusterRevision { -struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo -{ - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } -}; -} // namespace ClusterRevision - -struct TypeInfo -{ - struct DecodableType - { - static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } - - CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); - - Attributes::EnergyBalances::TypeInfo::DecodableType energyBalances; - Attributes::CurrentEnergyBalance::TypeInfo::DecodableType currentEnergyBalance = static_cast(0); - Attributes::EnergyPriorities::TypeInfo::DecodableType energyPriorities; - Attributes::LowPowerModeSensitivities::TypeInfo::DecodableType lowPowerModeSensitivities; - Attributes::CurrentLowPowerModeSensitivity::TypeInfo::DecodableType currentLowPowerModeSensitivity = - 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 EnergyPreference namespace DoorLock { namespace Structs { namespace CredentialStruct { 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 62785377b59df5..4695c568ad375b 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 @@ -3969,56 +3969,6 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; } // namespace Attributes } // namespace EnergyEvse -namespace EnergyPreference { -namespace Attributes { - -namespace EnergyBalances { -static constexpr AttributeId Id = 0x00000000; -} // namespace EnergyBalances - -namespace CurrentEnergyBalance { -static constexpr AttributeId Id = 0x00000001; -} // namespace CurrentEnergyBalance - -namespace EnergyPriorities { -static constexpr AttributeId Id = 0x00000002; -} // namespace EnergyPriorities - -namespace LowPowerModeSensitivities { -static constexpr AttributeId Id = 0x00000003; -} // namespace LowPowerModeSensitivities - -namespace CurrentLowPowerModeSensitivity { -static constexpr AttributeId Id = 0x00000004; -} // namespace CurrentLowPowerModeSensitivity - -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 EnergyPreference - namespace DoorLock { 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 22c0372ff8208b..c27144ce2d58f3 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 @@ -232,9 +232,6 @@ static constexpr ClusterId Id = 0x00000098; namespace EnergyEvse { static constexpr ClusterId Id = 0x00000099; } // namespace EnergyEvse -namespace EnergyPreference { -static constexpr ClusterId Id = 0x0000009B; -} // namespace EnergyPreference namespace DoorLock { static constexpr ClusterId Id = 0x00000101; } // namespace DoorLock 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 ff759011ffad1c..717678971f45de 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 @@ -471,12 +471,6 @@ #define CHIP_PRINTCLUSTER_ENERGY_EVSE_CLUSTER #endif -#if defined(ZCL_USING_ENERGY_PREFERENCE_CLUSTER_SERVER) || defined(ZCL_USING_ENERGY_PREFERENCE_CLUSTER_CLIENT) -#define CHIP_PRINTCLUSTER_ENERGY_PREFERENCE_CLUSTER { chip::app::Clusters::EnergyPreference::Id, "Energy Preference" }, -#else -#define CHIP_PRINTCLUSTER_ENERGY_PREFERENCE_CLUSTER -#endif - #if defined(ZCL_USING_DOOR_LOCK_CLUSTER_SERVER) || defined(ZCL_USING_DOOR_LOCK_CLUSTER_CLIENT) #define CHIP_PRINTCLUSTER_DOOR_LOCK_CLUSTER { chip::app::Clusters::DoorLock::Id, "Door Lock" }, #else @@ -835,7 +829,6 @@ CHIP_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ CHIP_PRINTCLUSTER_DEVICE_ENERGY_MANAGEMENT_CLUSTER \ CHIP_PRINTCLUSTER_ENERGY_EVSE_CLUSTER \ - CHIP_PRINTCLUSTER_ENERGY_PREFERENCE_CLUSTER \ CHIP_PRINTCLUSTER_DOOR_LOCK_CLUSTER \ CHIP_PRINTCLUSTER_WINDOW_COVERING_CLUSTER \ CHIP_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER \ diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index c1e1d69f59d802..b2cd6d369415c1 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -104,7 +104,6 @@ | DemandResponseLoadControl | 0x0096 | | DeviceEnergyManagement | 0x0098 | | EnergyEvse | 0x0099 | -| EnergyPreference | 0x009B | | DoorLock | 0x0101 | | WindowCovering | 0x0102 | | BarrierControl | 0x0103 | @@ -7475,27 +7474,6 @@ class EnergyEvseClearTargets : public ClusterCommand chip::app::Clusters::EnergyEvse::Commands::ClearTargets::Type mRequest; }; -/*----------------------------------------------------------------------------*\ -| Cluster EnergyPreference | 0x009B | -|------------------------------------------------------------------------------| -| Commands: | | -|------------------------------------------------------------------------------| -| Attributes: | | -| * EnergyBalances | 0x0000 | -| * CurrentEnergyBalance | 0x0001 | -| * EnergyPriorities | 0x0002 | -| * LowPowerModeSensitivities | 0x0003 | -| * CurrentLowPowerModeSensitivity | 0x0004 | -| * GeneratedCommandList | 0xFFF8 | -| * AcceptedCommandList | 0xFFF9 | -| * EventList | 0xFFFA | -| * AttributeList | 0xFFFB | -| * FeatureMap | 0xFFFC | -| * ClusterRevision | 0xFFFD | -|------------------------------------------------------------------------------| -| Events: | | -\*----------------------------------------------------------------------------*/ - /*----------------------------------------------------------------------------*\ | Cluster DoorLock | 0x0101 | |------------------------------------------------------------------------------| @@ -20379,86 +20357,6 @@ void registerClusterEnergyEvse(Commands & commands, CredentialIssuerCommands * c commands.RegisterCluster(clusterName, clusterCommands); } -void registerClusterEnergyPreference(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) -{ - using namespace chip::app::Clusters::EnergyPreference; - - const char * clusterName = "EnergyPreference"; - - commands_list clusterCommands = { - // - // Commands - // - make_unique(Id, credsIssuerConfig), // - // - // Attributes - // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, "energy-balances", Attributes::EnergyBalances::Id, credsIssuerConfig), // - make_unique(Id, "current-energy-balance", Attributes::CurrentEnergyBalance::Id, credsIssuerConfig), // - make_unique(Id, "energy-priorities", Attributes::EnergyPriorities::Id, credsIssuerConfig), // - make_unique(Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, - credsIssuerConfig), // - make_unique(Id, "current-low-power-mode-sensitivity", Attributes::CurrentLowPowerModeSensitivity::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, "energy-balances", Attributes::EnergyBalances::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // - make_unique>(Id, "current-energy-balance", 0, UINT8_MAX, Attributes::CurrentEnergyBalance::Id, - WriteCommandType::kWrite, credsIssuerConfig), // - make_unique< - WriteAttributeAsComplex>>( - Id, "energy-priorities", Attributes::EnergyPriorities::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // - make_unique>>( - Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, WriteCommandType::kForceWrite, - credsIssuerConfig), // - make_unique>(Id, "current-low-power-mode-sensitivity", 0, UINT8_MAX, - Attributes::CurrentLowPowerModeSensitivity::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, "energy-balances", Attributes::EnergyBalances::Id, credsIssuerConfig), // - make_unique(Id, "current-energy-balance", Attributes::CurrentEnergyBalance::Id, credsIssuerConfig), // - make_unique(Id, "energy-priorities", Attributes::EnergyPriorities::Id, credsIssuerConfig), // - make_unique(Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, - credsIssuerConfig), // - make_unique(Id, "current-low-power-mode-sensitivity", Attributes::CurrentLowPowerModeSensitivity::Id, - credsIssuerConfig), // - make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // - make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // - make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // - make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // - make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // - make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // - // - // Events - // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, credsIssuerConfig), // - }; - - commands.RegisterCluster(clusterName, clusterCommands); -} void registerClusterDoorLock(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) { using namespace chip::app::Clusters::DoorLock; @@ -26160,7 +26058,6 @@ void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssue registerClusterDemandResponseLoadControl(commands, credsIssuerConfig); registerClusterDeviceEnergyManagement(commands, credsIssuerConfig); registerClusterEnergyEvse(commands, credsIssuerConfig); - registerClusterEnergyPreference(commands, credsIssuerConfig); registerClusterDoorLock(commands, credsIssuerConfig); registerClusterWindowCovering(commands, credsIssuerConfig); registerClusterBarrierControl(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 d38c78eded3f2b..e1f6467987dd2c 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -2891,31 +2891,6 @@ 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 chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::DecodableType & value) -{ - DataModelLogger::LogString(label, indent, "{"); - { - CHIP_ERROR err = LogValue("Step", indent + 1, value.step); - if (err != CHIP_NO_ERROR) - { - DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Step'"); - return err; - } - } - { - CHIP_ERROR err = LogValue("Label", indent + 1, value.label); - if (err != CHIP_NO_ERROR) - { - DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Label'"); - return err; - } - } - DataModelLogger::LogString(indent, "}"); - - return CHIP_NO_ERROR; -} - CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const chip::app::Clusters::DoorLock::Structs::CredentialStruct::DecodableType & value) { @@ -12450,67 +12425,6 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP } break; } - case EnergyPreference::Id: { - switch (path.mAttributeId) - { - case EnergyPreference::Attributes::EnergyBalances::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("EnergyBalances", 1, value); - } - case EnergyPreference::Attributes::CurrentEnergyBalance::Id: { - uint8_t value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("CurrentEnergyBalance", 1, value); - } - case EnergyPreference::Attributes::EnergyPriorities::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("EnergyPriorities", 1, value); - } - case EnergyPreference::Attributes::LowPowerModeSensitivities::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("LowPowerModeSensitivities", 1, value); - } - case EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::Id: { - uint8_t value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("CurrentLowPowerModeSensitivity", 1, value); - } - case EnergyPreference::Attributes::GeneratedCommandList::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("GeneratedCommandList", 1, value); - } - case EnergyPreference::Attributes::AcceptedCommandList::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("AcceptedCommandList", 1, value); - } - case EnergyPreference::Attributes::EventList::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("EventList", 1, value); - } - case EnergyPreference::Attributes::AttributeList::Id: { - chip::app::DataModel::DecodableList value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("AttributeList", 1, value); - } - case EnergyPreference::Attributes::FeatureMap::Id: { - uint32_t value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("FeatureMap", 1, value); - } - case EnergyPreference::Attributes::ClusterRevision::Id: { - uint16_t value; - ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); - return DataModelLogger::LogValue("ClusterRevision", 1, value); - } - } - break; - } case DoorLock::Id: { switch (path.mAttributeId) { 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 49fd07683ab36e..2c50faa6194c2f 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -106,7 +106,6 @@ | DemandResponseLoadControl | 0x0096 | | DeviceEnergyManagement | 0x0098 | | EnergyEvse | 0x0099 | -| EnergyPreference | 0x009B | | DoorLock | 0x0101 | | WindowCovering | 0x0102 | | BarrierControl | 0x0103 | @@ -84363,1046 +84362,6 @@ class SubscribeAttributeEnergyEvseClusterRevision : public SubscribeAttribute { } }; -#endif // MTR_ENABLE_PROVISIONAL -#endif // MTR_ENABLE_PROVISIONAL -#if MTR_ENABLE_PROVISIONAL -/*----------------------------------------------------------------------------*\ -| Cluster EnergyPreference | 0x009B | -|------------------------------------------------------------------------------| -| Commands: | | -|------------------------------------------------------------------------------| -| Attributes: | | -| * EnergyBalances | 0x0000 | -| * CurrentEnergyBalance | 0x0001 | -| * EnergyPriorities | 0x0002 | -| * LowPowerModeSensitivities | 0x0003 | -| * CurrentLowPowerModeSensitivity | 0x0004 | -| * GeneratedCommandList | 0xFFF8 | -| * AcceptedCommandList | 0xFFF9 | -| * EventList | 0xFFFA | -| * AttributeList | 0xFFFB | -| * FeatureMap | 0xFFFC | -| * ClusterRevision | 0xFFFD | -|------------------------------------------------------------------------------| -| Events: | | -\*----------------------------------------------------------------------------*/ - -#if MTR_ENABLE_PROVISIONAL - -/* - * Attribute EnergyBalances - */ -class ReadEnergyPreferenceEnergyBalances : public ReadAttribute { -public: - ReadEnergyPreferenceEnergyBalances() - : ReadAttribute("energy-balances") - { - } - - ~ReadEnergyPreferenceEnergyBalances() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyBalances::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeEnergyBalancesWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.EnergyBalances response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference EnergyBalances read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceEnergyBalances : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceEnergyBalances() - : SubscribeAttribute("energy-balances") - { - } - - ~SubscribeAttributeEnergyPreferenceEnergyBalances() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyBalances::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeEnergyBalancesWithParams:params - subscriptionEstablished:^() { mSubscriptionEstablished = YES; } - reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.EnergyBalances 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 CurrentEnergyBalance - */ -class ReadEnergyPreferenceCurrentEnergyBalance : public ReadAttribute { -public: - ReadEnergyPreferenceCurrentEnergyBalance() - : ReadAttribute("current-energy-balance") - { - } - - ~ReadEnergyPreferenceCurrentEnergyBalance() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentEnergyBalance::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeCurrentEnergyBalanceWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.CurrentEnergyBalance response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference CurrentEnergyBalance read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class WriteEnergyPreferenceCurrentEnergyBalance : public WriteAttribute { -public: - WriteEnergyPreferenceCurrentEnergyBalance() - : WriteAttribute("current-energy-balance") - { - AddArgument("attr-name", "current-energy-balance"); - AddArgument("attr-value", 0, UINT8_MAX, &mValue); - WriteAttribute::AddArguments(); - } - - ~WriteEnergyPreferenceCurrentEnergyBalance() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentEnergyBalance::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 = [[MTRBaseClusterEnergyPreference 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 writeAttributeCurrentEnergyBalanceWithValue:value params:params completion:^(NSError * _Nullable error) { - if (error != nil) { - LogNSError("EnergyPreference CurrentEnergyBalance write Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } - -private: - uint8_t mValue; -}; - -class SubscribeAttributeEnergyPreferenceCurrentEnergyBalance : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceCurrentEnergyBalance() - : SubscribeAttribute("current-energy-balance") - { - } - - ~SubscribeAttributeEnergyPreferenceCurrentEnergyBalance() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentEnergyBalance::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeCurrentEnergyBalanceWithParams:params - subscriptionEstablished:^() { mSubscriptionEstablished = YES; } - reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.CurrentEnergyBalance 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 EnergyPriorities - */ -class ReadEnergyPreferenceEnergyPriorities : public ReadAttribute { -public: - ReadEnergyPreferenceEnergyPriorities() - : ReadAttribute("energy-priorities") - { - } - - ~ReadEnergyPreferenceEnergyPriorities() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyPriorities::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeEnergyPrioritiesWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.EnergyPriorities response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference EnergyPriorities read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceEnergyPriorities : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceEnergyPriorities() - : SubscribeAttribute("energy-priorities") - { - } - - ~SubscribeAttributeEnergyPreferenceEnergyPriorities() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyPriorities::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeEnergyPrioritiesWithParams:params - subscriptionEstablished:^() { mSubscriptionEstablished = YES; } - reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.EnergyPriorities 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 LowPowerModeSensitivities - */ -class ReadEnergyPreferenceLowPowerModeSensitivities : public ReadAttribute { -public: - ReadEnergyPreferenceLowPowerModeSensitivities() - : ReadAttribute("low-power-mode-sensitivities") - { - } - - ~ReadEnergyPreferenceLowPowerModeSensitivities() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::LowPowerModeSensitivities::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeLowPowerModeSensitivitiesWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.LowPowerModeSensitivities response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference LowPowerModeSensitivities read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceLowPowerModeSensitivities : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceLowPowerModeSensitivities() - : SubscribeAttribute("low-power-mode-sensitivities") - { - } - - ~SubscribeAttributeEnergyPreferenceLowPowerModeSensitivities() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::LowPowerModeSensitivities::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeLowPowerModeSensitivitiesWithParams:params - subscriptionEstablished:^() { mSubscriptionEstablished = YES; } - reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.LowPowerModeSensitivities 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 CurrentLowPowerModeSensitivity - */ -class ReadEnergyPreferenceCurrentLowPowerModeSensitivity : public ReadAttribute { -public: - ReadEnergyPreferenceCurrentLowPowerModeSensitivity() - : ReadAttribute("current-low-power-mode-sensitivity") - { - } - - ~ReadEnergyPreferenceCurrentLowPowerModeSensitivity() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeCurrentLowPowerModeSensitivityWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.CurrentLowPowerModeSensitivity response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference CurrentLowPowerModeSensitivity read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class WriteEnergyPreferenceCurrentLowPowerModeSensitivity : public WriteAttribute { -public: - WriteEnergyPreferenceCurrentLowPowerModeSensitivity() - : WriteAttribute("current-low-power-mode-sensitivity") - { - AddArgument("attr-name", "current-low-power-mode-sensitivity"); - AddArgument("attr-value", 0, UINT8_MAX, &mValue); - WriteAttribute::AddArguments(); - } - - ~WriteEnergyPreferenceCurrentLowPowerModeSensitivity() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = [[MTRBaseClusterEnergyPreference 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 writeAttributeCurrentLowPowerModeSensitivityWithValue:value params:params completion:^(NSError * _Nullable error) { - if (error != nil) { - LogNSError("EnergyPreference CurrentLowPowerModeSensitivity write Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } - -private: - uint8_t mValue; -}; - -class SubscribeAttributeEnergyPreferenceCurrentLowPowerModeSensitivity : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceCurrentLowPowerModeSensitivity() - : SubscribeAttribute("current-low-power-mode-sensitivity") - { - } - - ~SubscribeAttributeEnergyPreferenceCurrentLowPowerModeSensitivity() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeCurrentLowPowerModeSensitivityWithParams:params - subscriptionEstablished:^() { mSubscriptionEstablished = YES; } - reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.CurrentLowPowerModeSensitivity 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 ReadEnergyPreferenceGeneratedCommandList : public ReadAttribute { -public: - ReadEnergyPreferenceGeneratedCommandList() - : ReadAttribute("generated-command-list") - { - } - - ~ReadEnergyPreferenceGeneratedCommandList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.GeneratedCommandList response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference GeneratedCommandList read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceGeneratedCommandList : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceGeneratedCommandList() - : SubscribeAttribute("generated-command-list") - { - } - - ~SubscribeAttributeEnergyPreferenceGeneratedCommandList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceAcceptedCommandList : public ReadAttribute { -public: - ReadEnergyPreferenceAcceptedCommandList() - : ReadAttribute("accepted-command-list") - { - } - - ~ReadEnergyPreferenceAcceptedCommandList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.AcceptedCommandList response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference AcceptedCommandList read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceAcceptedCommandList : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceAcceptedCommandList() - : SubscribeAttribute("accepted-command-list") - { - } - - ~SubscribeAttributeEnergyPreferenceAcceptedCommandList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceEventList : public ReadAttribute { -public: - ReadEnergyPreferenceEventList() - : ReadAttribute("event-list") - { - } - - ~ReadEnergyPreferenceEventList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.EventList response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference EventList read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceEventList : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceEventList() - : SubscribeAttribute("event-list") - { - } - - ~SubscribeAttributeEnergyPreferenceEventList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceAttributeList : public ReadAttribute { -public: - ReadEnergyPreferenceAttributeList() - : ReadAttribute("attribute-list") - { - } - - ~ReadEnergyPreferenceAttributeList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.AttributeList response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference AttributeList read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceAttributeList : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceAttributeList() - : SubscribeAttribute("attribute-list") - { - } - - ~SubscribeAttributeEnergyPreferenceAttributeList() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceFeatureMap : public ReadAttribute { -public: - ReadEnergyPreferenceFeatureMap() - : ReadAttribute("feature-map") - { - } - - ~ReadEnergyPreferenceFeatureMap() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.FeatureMap response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference FeatureMap read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceFeatureMap : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceFeatureMap() - : SubscribeAttribute("feature-map") - { - } - - ~SubscribeAttributeEnergyPreferenceFeatureMap() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceClusterRevision : public ReadAttribute { -public: - ReadEnergyPreferenceClusterRevision() - : ReadAttribute("cluster-revision") - { - } - - ~ReadEnergyPreferenceClusterRevision() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; - [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { - NSLog(@"EnergyPreference.ClusterRevision response %@", [value description]); - if (error == nil) { - RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); - } else { - LogNSError("EnergyPreference ClusterRevision read Error", error); - RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); - } - SetCommandExitStatus(error); - }]; - return CHIP_NO_ERROR; - } -}; - -class SubscribeAttributeEnergyPreferenceClusterRevision : public SubscribeAttribute { -public: - SubscribeAttributeEnergyPreferenceClusterRevision() - : SubscribeAttribute("cluster-revision") - { - } - - ~SubscribeAttributeEnergyPreferenceClusterRevision() - { - } - - CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override - { - constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; - constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 /*----------------------------------------------------------------------------*\ @@ -181683,69 +180642,6 @@ void registerClusterEnergyEvse(Commands & commands) commands.RegisterCluster(clusterName, clusterCommands); #endif // MTR_ENABLE_PROVISIONAL } -void registerClusterEnergyPreference(Commands & commands) -{ -#if MTR_ENABLE_PROVISIONAL - using namespace chip::app::Clusters::EnergyPreference; - - const char * clusterName = "EnergyPreference"; - - commands_list clusterCommands = { - make_unique(Id), // - make_unique(Id), // - make_unique(Id), // - make_unique(Id), // -#if MTR_ENABLE_PROVISIONAL - make_unique(), // - make_unique(), // -#endif // MTR_ENABLE_PROVISIONAL -#if MTR_ENABLE_PROVISIONAL - make_unique(), // - make_unique(), // - 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 - }; - - commands.RegisterCluster(clusterName, clusterCommands); -#endif // MTR_ENABLE_PROVISIONAL -} void registerClusterDoorLock(Commands & commands) { using namespace chip::app::Clusters::DoorLock; @@ -185200,7 +184096,6 @@ void registerClusters(Commands & commands) registerClusterDemandResponseLoadControl(commands); registerClusterDeviceEnergyManagement(commands); registerClusterEnergyEvse(commands); - registerClusterEnergyPreference(commands); registerClusterDoorLock(commands); registerClusterWindowCovering(commands); registerClusterBarrierControl(commands); From 67f420b39c3d1c217ae585e11b8cac107d39c731 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Wed, 20 Dec 2023 22:25:49 -0600 Subject: [PATCH 02/26] Fix linter error --- src/controller/python/chip/clusters/__init__.py | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/src/controller/python/chip/clusters/__init__.py b/src/controller/python/chip/clusters/__init__.py index aaf9da3cef301f..9388432381ef69 100644 --- a/src/controller/python/chip/clusters/__init__.py +++ b/src/controller/python/chip/clusters/__init__.py @@ -31,18 +31,11 @@ DoorLock, ElectricalMeasurement, EnergyEvse, EthernetNetworkDiagnostics, FanControl, FaultInjection, FixedLabel, FlowMeasurement, FormaldehydeConcentrationMeasurement, GeneralCommissioning, GeneralDiagnostics, GroupKeyManagement, Groups, HepaFilterMonitoring, IcdManagement, Identify, IlluminanceMeasurement, -<<<<<<< HEAD KeypadInput, LaundryDryerControls, LaundryWasherControls, LaundryWasherMode, LevelControl, LocalizationConfiguration, LowPower, MediaInput, MediaPlayback, MicrowaveOvenControl, MicrowaveOvenMode, ModeSelect, NetworkCommissioning, NitrogenDioxideConcentrationMeasurement, OccupancySensing, OnOff, OnOffSwitchConfiguration, OperationalCredentials, OperationalState, OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor, OvenCavityOperationalState, OvenMode, OzoneConcentrationMeasurement, -======= - KeypadInput, LaundryWasherControls, LaundryWasherMode, LevelControl, LocalizationConfiguration, LowPower, - MediaInput, MediaPlayback, ModeSelect, NetworkCommissioning, NitrogenDioxideConcentrationMeasurement, - OccupancySensing, OnOff, OnOffSwitchConfiguration, OperationalCredentials, OperationalState, - OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor, OvenCavityOperationalState, OzoneConcentrationMeasurement, ->>>>>>> 08e84a9c13 (Initial OpState work) Pm1ConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm25ConcentrationMeasurement, PowerSource, PowerSourceConfiguration, PressureMeasurement, ProxyConfiguration, ProxyDiscovery, ProxyValid, PulseWidthModulation, PumpConfigurationAndControl, RadonConcentrationMeasurement, RefrigeratorAlarm, @@ -66,11 +59,7 @@ LaundryWasherControls, LaundryWasherMode, LevelControl, LocalizationConfiguration, LowPower, MediaInput, MediaPlayback, MicrowaveOvenControl, MicrowaveOvenMode, ModeSelect, NetworkCommissioning, NitrogenDioxideConcentrationMeasurement, OccupancySensing, OnOff, OnOffSwitchConfiguration, OperationalCredentials, OperationalState, -<<<<<<< HEAD OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor, OvenCavityOperationalState, OvenMode, -======= - OtaSoftwareUpdateProvider, OtaSoftwareUpdateRequestor,OvenCavityOperationalState, ->>>>>>> 08e84a9c13 (Initial OpState work) OzoneConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm25ConcentrationMeasurement, PowerSource, PowerSourceConfiguration, PressureMeasurement, ProxyConfiguration, ProxyDiscovery, ProxyValid, PulseWidthModulation, PumpConfigurationAndControl, RadonConcentrationMeasurement, From 0b4738a61ae423caa20b28c0a355d1edf80860cf Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Wed, 20 Dec 2023 23:08:19 -0600 Subject: [PATCH 03/26] zap regen --- .../chip/devicecontroller/ChipClusters.java | 347 ++++++ .../devicecontroller/ChipEventStructs.java | 930 +++++++++++++- .../chip/devicecontroller/ChipStructs.java | 61 + .../devicecontroller/ClusterIDMapping.java | 108 ++ .../devicecontroller/ClusterInfoMapping.java | 156 +++ .../devicecontroller/ClusterReadMapping.java | 126 ++ .../devicecontroller/ClusterWriteMapping.java | 46 + .../chip/devicecontroller/cluster/files.gni | 1 + .../CHIPEventTLVValueDecoder.cpp | 10 + .../java/zap-generated/CHIPReadCallbacks.cpp | 565 +++++++++ .../python/chip/clusters/CHIPClusters.py | 78 ++ .../python/chip/clusters/Objects.py | 242 ++++ .../MTRAttributeSpecifiedCheck.mm | 45 + .../MTRAttributeTLVValueDecoder.mm | 137 ++ .../CHIP/zap-generated/MTRBaseClusters.h | 107 ++ .../CHIP/zap-generated/MTRBaseClusters.mm | 456 +++++++ .../CHIP/zap-generated/MTRClusterConstants.h | 14 + .../CHIP/zap-generated/MTRClusters.h | 50 + .../CHIP/zap-generated/MTRClusters.mm | 81 ++ .../zap-generated/MTRCommandTimedCheck.mm | 12 + .../zap-generated/MTREventTLVValueDecoder.mm | 15 + .../CHIP/zap-generated/MTRStructsObjc.h | 6 + .../CHIP/zap-generated/MTRStructsObjc.mm | 30 + .../zap-generated/attributes/Accessors.cpp | 130 ++ .../zap-generated/attributes/Accessors.h | 26 + .../zap-generated/cluster-enums-check.h | 15 + .../app-common/zap-generated/cluster-enums.h | 24 + .../zap-generated/cluster-objects.cpp | 83 ++ .../zap-generated/cluster-objects.h | 154 +++ .../app-common/zap-generated/ids/Attributes.h | 50 + .../app-common/zap-generated/ids/Clusters.h | 3 + .../app-common/zap-generated/print-cluster.h | 7 + .../zap-generated/cluster/Commands.h | 103 ++ .../cluster/logging/DataModelLogger.cpp | 86 ++ .../zap-generated/cluster/Commands.h | 1105 +++++++++++++++++ 35 files changed, 5406 insertions(+), 3 deletions(-) diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java index 784fef07bf62af..8eb7fcdcee4b3a 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java @@ -31012,6 +31012,353 @@ public void onSuccess(byte[] tlv) { } } + public static class EnergyPreferenceCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 155L; + + private static final long ENERGY_BALANCES_ATTRIBUTE_ID = 0L; + private static final long CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID = 1L; + private static final long ENERGY_PRIORITIES_ATTRIBUTE_ID = 2L; + private static final long LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID = 3L; + private static final long CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID = 4L; + 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 EnergyPreferenceCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId, CLUSTER_ID); + } + + @Override + @Deprecated + public long initWithDevice(long devicePtr, int endpointId) { + return 0L; + } + + public interface EnergyBalancesAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface EnergyPrioritiesAttributeCallback extends BaseAttributeCallback { + void onSuccess(List value); + } + + public interface LowPowerModeSensitivitiesAttributeCallback extends BaseAttributeCallback { + void onSuccess(List 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 readEnergyBalancesAttribute( + EnergyBalancesAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_BALANCES_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ENERGY_BALANCES_ATTRIBUTE_ID, true); + } + + public void subscribeEnergyBalancesAttribute( + EnergyBalancesAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_BALANCES_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ENERGY_BALANCES_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readCurrentEnergyBalanceAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID, true); + } + + public void writeCurrentEnergyBalanceAttribute(DefaultClusterCallback callback, Integer value) { + writeCurrentEnergyBalanceAttribute(callback, value, 0); + } + + public void writeCurrentEnergyBalanceAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = new UIntType(value); + writeAttribute(new WriteAttributesCallbackImpl(callback), CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeCurrentEnergyBalanceAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, CURRENT_ENERGY_BALANCE_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readEnergyPrioritiesAttribute( + EnergyPrioritiesAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_PRIORITIES_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, ENERGY_PRIORITIES_ATTRIBUTE_ID, true); + } + + public void subscribeEnergyPrioritiesAttribute( + EnergyPrioritiesAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENERGY_PRIORITIES_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, ENERGY_PRIORITIES_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readLowPowerModeSensitivitiesAttribute( + LowPowerModeSensitivitiesAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID, true); + } + + public void subscribeLowPowerModeSensitivitiesAttribute( + LowPowerModeSensitivitiesAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, LOW_POWER_MODE_SENSITIVITIES_ATTRIBUTE_ID, minInterval, maxInterval); + } + + public void readCurrentLowPowerModeSensitivityAttribute( + IntegerAttributeCallback callback) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID); + + readAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + callback.onSuccess(value); + } + }, CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID, true); + } + + public void writeCurrentLowPowerModeSensitivityAttribute(DefaultClusterCallback callback, Integer value) { + writeCurrentLowPowerModeSensitivityAttribute(callback, value, 0); + } + + public void writeCurrentLowPowerModeSensitivityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + BaseTLVType tlvValue = new UIntType(value); + writeAttribute(new WriteAttributesCallbackImpl(callback), CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs); + } + + public void subscribeCurrentLowPowerModeSensitivityAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LOW_POWER_MODE_SENSITIVITY_ATTRIBUTE_ID); + + subscribeAttribute(new ReportCallbackImpl(callback, path) { + @Override + public void onSuccess(byte[] tlv) { + Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv); + } + }, CURRENT_LOW_POWER_MODE_SENSITIVITY_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 DoorLockCluster extends BaseChipCluster { public static final long CLUSTER_ID = 257L; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java index 46817d28431755..9f5c25260c131b 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java @@ -449,6 +449,34 @@ public String toString() { return output.toString(); } } +public static class BasicInformationClusterShutDownEvent { + + public BasicInformationClusterShutDownEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static BasicInformationClusterShutDownEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new BasicInformationClusterShutDownEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BasicInformationClusterShutDownEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class BasicInformationClusterLeaveEvent { public Integer fabricIndex; private static final long FABRIC_INDEX_ID = 0L; @@ -1532,6 +1560,34 @@ public String toString() { return output.toString(); } } +public static class TimeSynchronizationClusterDSTTableEmptyEvent { + + public TimeSynchronizationClusterDSTTableEmptyEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static TimeSynchronizationClusterDSTTableEmptyEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new TimeSynchronizationClusterDSTTableEmptyEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TimeSynchronizationClusterDSTTableEmptyEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class TimeSynchronizationClusterDSTStatusEvent { public Boolean DSTOffsetActive; private static final long D_S_T_OFFSET_ACTIVE_ID = 0L; @@ -1639,6 +1695,62 @@ public String toString() { return output.toString(); } } +public static class TimeSynchronizationClusterTimeFailureEvent { + + public TimeSynchronizationClusterTimeFailureEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static TimeSynchronizationClusterTimeFailureEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new TimeSynchronizationClusterTimeFailureEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TimeSynchronizationClusterTimeFailureEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class TimeSynchronizationClusterMissingTrustedTimeSourceEvent { + + public TimeSynchronizationClusterMissingTrustedTimeSourceEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static TimeSynchronizationClusterMissingTrustedTimeSourceEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new TimeSynchronizationClusterMissingTrustedTimeSourceEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TimeSynchronizationClusterMissingTrustedTimeSourceEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class BridgedDeviceBasicInformationClusterStartUpEvent { public Long softwareVersion; private static final long SOFTWARE_VERSION_ID = 0L; @@ -1685,6 +1797,62 @@ public String toString() { return output.toString(); } } +public static class BridgedDeviceBasicInformationClusterShutDownEvent { + + public BridgedDeviceBasicInformationClusterShutDownEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static BridgedDeviceBasicInformationClusterShutDownEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new BridgedDeviceBasicInformationClusterShutDownEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedDeviceBasicInformationClusterShutDownEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class BridgedDeviceBasicInformationClusterLeaveEvent { + + public BridgedDeviceBasicInformationClusterLeaveEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static BridgedDeviceBasicInformationClusterLeaveEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new BridgedDeviceBasicInformationClusterLeaveEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedDeviceBasicInformationClusterLeaveEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class BridgedDeviceBasicInformationClusterReachableChangedEvent { public Boolean reachableNewValue; private static final long REACHABLE_NEW_VALUE_ID = 0L; @@ -2508,6 +2676,146 @@ public String toString() { return output.toString(); } } +public static class SmokeCoAlarmClusterHardwareFaultEvent { + + public SmokeCoAlarmClusterHardwareFaultEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static SmokeCoAlarmClusterHardwareFaultEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new SmokeCoAlarmClusterHardwareFaultEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterHardwareFaultEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class SmokeCoAlarmClusterEndOfServiceEvent { + + public SmokeCoAlarmClusterEndOfServiceEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static SmokeCoAlarmClusterEndOfServiceEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new SmokeCoAlarmClusterEndOfServiceEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterEndOfServiceEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class SmokeCoAlarmClusterSelfTestCompleteEvent { + + public SmokeCoAlarmClusterSelfTestCompleteEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static SmokeCoAlarmClusterSelfTestCompleteEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new SmokeCoAlarmClusterSelfTestCompleteEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterSelfTestCompleteEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class SmokeCoAlarmClusterAlarmMutedEvent { + + public SmokeCoAlarmClusterAlarmMutedEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static SmokeCoAlarmClusterAlarmMutedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new SmokeCoAlarmClusterAlarmMutedEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterAlarmMutedEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class SmokeCoAlarmClusterMuteEndedEvent { + + public SmokeCoAlarmClusterMuteEndedEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static SmokeCoAlarmClusterMuteEndedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new SmokeCoAlarmClusterMuteEndedEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterMuteEndedEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class SmokeCoAlarmClusterInterconnectSmokeAlarmEvent { public Integer alarmSeverityLevel; private static final long ALARM_SEVERITY_LEVEL_ID = 0L; @@ -2600,9 +2908,37 @@ public String toString() { return output.toString(); } } -public static class DishwasherAlarmClusterNotifyEvent { - public Long active; - public Long inactive; +public static class SmokeCoAlarmClusterAllClearEvent { + + public SmokeCoAlarmClusterAllClearEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static SmokeCoAlarmClusterAllClearEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new SmokeCoAlarmClusterAllClearEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SmokeCoAlarmClusterAllClearEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class DishwasherAlarmClusterNotifyEvent { + public Long active; + public Long inactive; public Long state; public Long mask; private static final long ACTIVE_ID = 0L; @@ -3452,6 +3788,34 @@ public String toString() { return output.toString(); } } +public static class DeviceEnergyManagementClusterPowerAdjustStartEvent { + + public DeviceEnergyManagementClusterPowerAdjustStartEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static DeviceEnergyManagementClusterPowerAdjustStartEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new DeviceEnergyManagementClusterPowerAdjustStartEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DeviceEnergyManagementClusterPowerAdjustStartEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class DeviceEnergyManagementClusterPowerAdjustEndEvent { public Integer cause; public Long duration; @@ -3528,6 +3892,62 @@ public String toString() { return output.toString(); } } +public static class DeviceEnergyManagementClusterPausedEvent { + + public DeviceEnergyManagementClusterPausedEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static DeviceEnergyManagementClusterPausedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new DeviceEnergyManagementClusterPausedEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DeviceEnergyManagementClusterPausedEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class DeviceEnergyManagementClusterResumedEvent { + + public DeviceEnergyManagementClusterResumedEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static DeviceEnergyManagementClusterResumedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new DeviceEnergyManagementClusterResumedEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DeviceEnergyManagementClusterResumedEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class EnergyEvseClusterEVConnectedEvent { public Long sessionID; private static final long SESSION_I_D_ID = 0L; @@ -4469,6 +4889,482 @@ public String toString() { return output.toString(); } } +public static class PumpConfigurationAndControlClusterSupplyVoltageLowEvent { + + public PumpConfigurationAndControlClusterSupplyVoltageLowEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterSupplyVoltageLowEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterSupplyVoltageLowEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterSupplyVoltageLowEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterSupplyVoltageHighEvent { + + public PumpConfigurationAndControlClusterSupplyVoltageHighEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterSupplyVoltageHighEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterSupplyVoltageHighEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterSupplyVoltageHighEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterPowerMissingPhaseEvent { + + public PumpConfigurationAndControlClusterPowerMissingPhaseEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterPowerMissingPhaseEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterPowerMissingPhaseEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterPowerMissingPhaseEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterSystemPressureLowEvent { + + public PumpConfigurationAndControlClusterSystemPressureLowEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterSystemPressureLowEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterSystemPressureLowEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterSystemPressureLowEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterSystemPressureHighEvent { + + public PumpConfigurationAndControlClusterSystemPressureHighEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterSystemPressureHighEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterSystemPressureHighEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterSystemPressureHighEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterDryRunningEvent { + + public PumpConfigurationAndControlClusterDryRunningEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterDryRunningEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterDryRunningEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterDryRunningEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterMotorTemperatureHighEvent { + + public PumpConfigurationAndControlClusterMotorTemperatureHighEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterMotorTemperatureHighEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterMotorTemperatureHighEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterMotorTemperatureHighEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent { + + public PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterPumpMotorFatalFailureEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterElectronicTemperatureHighEvent { + + public PumpConfigurationAndControlClusterElectronicTemperatureHighEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterElectronicTemperatureHighEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterElectronicTemperatureHighEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterElectronicTemperatureHighEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterPumpBlockedEvent { + + public PumpConfigurationAndControlClusterPumpBlockedEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterPumpBlockedEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterPumpBlockedEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterPumpBlockedEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterSensorFailureEvent { + + public PumpConfigurationAndControlClusterSensorFailureEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterSensorFailureEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterSensorFailureEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterSensorFailureEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent { + + public PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterElectronicNonFatalFailureEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterElectronicFatalFailureEvent { + + public PumpConfigurationAndControlClusterElectronicFatalFailureEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterElectronicFatalFailureEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterElectronicFatalFailureEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterElectronicFatalFailureEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterGeneralFaultEvent { + + public PumpConfigurationAndControlClusterGeneralFaultEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterGeneralFaultEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterGeneralFaultEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterGeneralFaultEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterLeakageEvent { + + public PumpConfigurationAndControlClusterLeakageEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterLeakageEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterLeakageEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterLeakageEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterAirDetectionEvent { + + public PumpConfigurationAndControlClusterAirDetectionEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterAirDetectionEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterAirDetectionEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterAirDetectionEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class PumpConfigurationAndControlClusterTurbineOperationEvent { + + public PumpConfigurationAndControlClusterTurbineOperationEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static PumpConfigurationAndControlClusterTurbineOperationEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new PumpConfigurationAndControlClusterTurbineOperationEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PumpConfigurationAndControlClusterTurbineOperationEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class TargetNavigatorClusterTargetUpdatedEvent { public ArrayList targetList; public Integer currentTarget; @@ -4757,6 +5653,34 @@ public String toString() { return output.toString(); } } +public static class ContentControlClusterRemainingScreenTimeExpiredEvent { + + public ContentControlClusterRemainingScreenTimeExpiredEvent( + ) { + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + + return new StructType(values); + } + + public static ContentControlClusterRemainingScreenTimeExpiredEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + return new ContentControlClusterRemainingScreenTimeExpiredEvent( + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentControlClusterRemainingScreenTimeExpiredEvent {\n"); + output.append("}\n"); + return output.toString(); + } +} public static class UnitTestingClusterTestEventEvent { public Integer arg1; public Integer arg2; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java index 68baadbbe4d8fc..9e36accf1b129a 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java @@ -7351,6 +7351,67 @@ public String toString() { return output.toString(); } } +public static class EnergyPreferenceClusterBalanceStruct { + public Integer step; + public Optional label; + private static final long STEP_ID = 0L; + private static final long LABEL_ID = 1L; + + public EnergyPreferenceClusterBalanceStruct( + Integer step, + Optional label + ) { + this.step = step; + this.label = label; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(STEP_ID, new UIntType(step))); + values.add(new StructElement(LABEL_ID, label.map((nonOptionallabel) -> new StringType(nonOptionallabel)).orElse(new EmptyType()))); + + return new StructType(values); + } + + public static EnergyPreferenceClusterBalanceStruct decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer step = null; + Optional label = Optional.empty(); + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == STEP_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + step = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == LABEL_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.String) { + StringType castingValue = element.value(StringType.class); + label = Optional.of(castingValue.value(String.class)); + } + } + } + return new EnergyPreferenceClusterBalanceStruct( + step, + label + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("EnergyPreferenceClusterBalanceStruct {\n"); + output.append("\tstep: "); + output.append(step); + output.append("\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} public static class DoorLockClusterCredentialStruct { public Integer credentialType; public Integer credentialIndex; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 1f02636b05aab7..a1be6ce8ae6bd1 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -235,6 +235,9 @@ public static BaseCluster getCluster(long clusterId) { if (clusterId == EnergyEvse.ID) { return new EnergyEvse(); } + if (clusterId == EnergyPreference.ID) { + return new EnergyPreference(); + } if (clusterId == DoorLock.ID) { return new DoorLock(); } @@ -9750,6 +9753,111 @@ public long getCommandID(String name) throws IllegalArgumentException { return Command.valueOf(name).getID(); } } + public static class EnergyPreference implements BaseCluster { + public static final long ID = 155L; + public long getID() { + return ID; + } + + public enum Attribute { + EnergyBalances(0L), + CurrentEnergyBalance(1L), + EnergyPriorities(2L), + LowPowerModeSensitivities(3L), + CurrentLowPowerModeSensitivity(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + 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(); + } + }@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 DoorLock implements BaseCluster { public static final long ID = 257L; 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 a2ebb9c79ced48..10007746d7dd7b 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java @@ -10915,6 +10915,153 @@ public void onError(Exception ex) { } } + public static class DelegatedEnergyPreferenceClusterEnergyBalancesAttributeCallback implements ChipClusters.EnergyPreferenceCluster.EnergyBalancesAttributeCallback, 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 DelegatedEnergyPreferenceClusterEnergyPrioritiesAttributeCallback implements ChipClusters.EnergyPreferenceCluster.EnergyPrioritiesAttributeCallback, 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 DelegatedEnergyPreferenceClusterLowPowerModeSensitivitiesAttributeCallback implements ChipClusters.EnergyPreferenceCluster.LowPowerModeSensitivitiesAttributeCallback, 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 DelegatedEnergyPreferenceClusterGeneratedCommandListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedEnergyPreferenceClusterAcceptedCommandListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedEnergyPreferenceClusterEventListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedEnergyPreferenceClusterAttributeListAttributeCallback implements ChipClusters.EnergyPreferenceCluster.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 DelegatedDoorLockClusterGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @@ -19907,6 +20054,10 @@ public Map initializeClusterMap() { (ptr, endpointId) -> new ChipClusters.EnergyEvseCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("energyEvse", energyEvseClusterInfo); + ClusterInfo energyPreferenceClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.EnergyPreferenceCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("energyPreference", energyPreferenceClusterInfo); + ClusterInfo doorLockClusterInfo = new ClusterInfo( (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("doorLock", doorLockClusterInfo); @@ -20152,6 +20303,7 @@ public void combineCommand(Map destination, Map> getCommandMap() { commandMap.put("energyEvse", energyEvseClusterInteractionInfoMap); + Map energyPreferenceClusterInteractionInfoMap = new LinkedHashMap<>(); + + commandMap.put("energyPreference", energyPreferenceClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); Map doorLocklockDoorCommandParams = 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 9199ac3dc8ab96..64a4a7a1ff08c7 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -9750,6 +9750,131 @@ private static Map readEnergyEvseInteractionInfo() { return result; } + private static Map readEnergyPreferenceInteractionInfo() { + Map result = new LinkedHashMap<>();Map readEnergyPreferenceEnergyBalancesCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceEnergyBalancesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readEnergyBalancesAttribute( + (ChipClusters.EnergyPreferenceCluster.EnergyBalancesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterEnergyBalancesAttributeCallback(), + readEnergyPreferenceEnergyBalancesCommandParams + ); + result.put("readEnergyBalancesAttribute", readEnergyPreferenceEnergyBalancesAttributeInteractionInfo); + Map readEnergyPreferenceCurrentEnergyBalanceCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readCurrentEnergyBalanceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEnergyPreferenceCurrentEnergyBalanceCommandParams + ); + result.put("readCurrentEnergyBalanceAttribute", readEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo); + Map readEnergyPreferenceEnergyPrioritiesCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceEnergyPrioritiesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readEnergyPrioritiesAttribute( + (ChipClusters.EnergyPreferenceCluster.EnergyPrioritiesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterEnergyPrioritiesAttributeCallback(), + readEnergyPreferenceEnergyPrioritiesCommandParams + ); + result.put("readEnergyPrioritiesAttribute", readEnergyPreferenceEnergyPrioritiesAttributeInteractionInfo); + Map readEnergyPreferenceLowPowerModeSensitivitiesCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceLowPowerModeSensitivitiesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readLowPowerModeSensitivitiesAttribute( + (ChipClusters.EnergyPreferenceCluster.LowPowerModeSensitivitiesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterLowPowerModeSensitivitiesAttributeCallback(), + readEnergyPreferenceLowPowerModeSensitivitiesCommandParams + ); + result.put("readLowPowerModeSensitivitiesAttribute", readEnergyPreferenceLowPowerModeSensitivitiesAttributeInteractionInfo); + Map readEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readCurrentLowPowerModeSensitivityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams + ); + result.put("readCurrentLowPowerModeSensitivityAttribute", readEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo); + Map readEnergyPreferenceGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.EnergyPreferenceCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterGeneratedCommandListAttributeCallback(), + readEnergyPreferenceGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readEnergyPreferenceGeneratedCommandListAttributeInteractionInfo); + Map readEnergyPreferenceAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.EnergyPreferenceCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterAcceptedCommandListAttributeCallback(), + readEnergyPreferenceAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readEnergyPreferenceAcceptedCommandListAttributeInteractionInfo); + Map readEnergyPreferenceEventListCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readEventListAttribute( + (ChipClusters.EnergyPreferenceCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterEventListAttributeCallback(), + readEnergyPreferenceEventListCommandParams + ); + result.put("readEventListAttribute", readEnergyPreferenceEventListAttributeInteractionInfo); + Map readEnergyPreferenceAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readAttributeListAttribute( + (ChipClusters.EnergyPreferenceCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEnergyPreferenceClusterAttributeListAttributeCallback(), + readEnergyPreferenceAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readEnergyPreferenceAttributeListAttributeInteractionInfo); + Map readEnergyPreferenceFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEnergyPreferenceFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readEnergyPreferenceFeatureMapAttributeInteractionInfo); + Map readEnergyPreferenceClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readEnergyPreferenceClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEnergyPreferenceClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readEnergyPreferenceClusterRevisionAttributeInteractionInfo); + + return result; + } private static Map readDoorLockInteractionInfo() { Map result = new LinkedHashMap<>();Map readDoorLockLockStateCommandParams = new LinkedHashMap(); InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( @@ -19818,6 +19943,7 @@ public Map> getReadAttributeMap() { put("demandResponseLoadControl", readDemandResponseLoadControlInteractionInfo()); put("deviceEnergyManagement", readDeviceEnergyManagementInteractionInfo()); put("energyEvse", readEnergyEvseInteractionInfo()); + put("energyPreference", readEnergyPreferenceInteractionInfo()); put("doorLock", readDoorLockInteractionInfo()); put("windowCovering", readWindowCoveringInteractionInfo()); put("barrierControl", readBarrierControlInteractionInfo()); diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index 4d3c50d8d8d89a..c3003c33ed19e0 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -1352,6 +1352,52 @@ public Map> getWriteAttributeMap() { ); writeEnergyEvseInteractionInfo.put("writeApproximateEVEfficiencyAttribute", writeEnergyEvseApproximateEVEfficiencyAttributeInteractionInfo); writeAttributeMap.put("energyEvse", writeEnergyEvseInteractionInfo); + Map writeEnergyPreferenceInteractionInfo = new LinkedHashMap<>(); + Map writeEnergyPreferenceCurrentEnergyBalanceCommandParams = new LinkedHashMap(); + CommandParameterInfo energyPreferencecurrentEnergyBalanceCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeEnergyPreferenceCurrentEnergyBalanceCommandParams.put( + "value", + energyPreferencecurrentEnergyBalanceCommandParameterInfo + ); + InteractionInfo writeEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).writeCurrentEnergyBalanceAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeEnergyPreferenceCurrentEnergyBalanceCommandParams + ); + writeEnergyPreferenceInteractionInfo.put("writeCurrentEnergyBalanceAttribute", writeEnergyPreferenceCurrentEnergyBalanceAttributeInteractionInfo); + Map writeEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams = new LinkedHashMap(); + CommandParameterInfo energyPreferencecurrentLowPowerModeSensitivityCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams.put( + "value", + energyPreferencecurrentLowPowerModeSensitivityCommandParameterInfo + ); + InteractionInfo writeEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EnergyPreferenceCluster) cluster).writeCurrentLowPowerModeSensitivityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeEnergyPreferenceCurrentLowPowerModeSensitivityCommandParams + ); + writeEnergyPreferenceInteractionInfo.put("writeCurrentLowPowerModeSensitivityAttribute", writeEnergyPreferenceCurrentLowPowerModeSensitivityAttributeInteractionInfo); + writeAttributeMap.put("energyPreference", writeEnergyPreferenceInteractionInfo); Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); Map writeDoorLockDoorOpenEventsCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockdoorOpenEventsCommandParameterInfo = 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 01d57d29c09e79..1cbd4a38983f5c 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni @@ -57,6 +57,7 @@ structs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ElectricalEnergyMeasurementClusterMeasurementAccuracyRangeStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/ElectricalEnergyMeasurementClusterMeasurementAccuracyStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyPreferenceClusterBalanceStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/FixedLabelClusterLabelStruct.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/GeneralCommissioningClusterBasicCommissioningInfo.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/GeneralDiagnosticsClusterNetworkInterface.kt", diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index 5785dc976dff93..2dc5ac3303b7df 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -5653,6 +5653,16 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } break; } + case app::Clusters::EnergyPreference::Id: { + using namespace app::Clusters::EnergyPreference; + switch (aPath.mEventId) + { + default: + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + break; + } + break; + } case app::Clusters::DoorLock::Id: { using namespace app::Clusters::DoorLock; switch (aPath.mEventId) diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index 827f73f4f74a50..111a9bf547e544 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -35181,6 +35181,571 @@ void CHIPEnergyPreferenceAttributeListAttributeCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPEnergyPreferenceEnergyBalancesAttributeCallback::CHIPEnergyPreferenceEnergyBalancesAttributeCallback(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"); + } +} + +CHIPEnergyPreferenceEnergyBalancesAttributeCallback::~CHIPEnergyPreferenceEnergyBalancesAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceEnergyBalancesAttributeCallback::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; + jobject newElement_0_step; + std::string newElement_0_stepClassName = "java/lang/Integer"; + std::string newElement_0_stepCtorSignature = "(I)V"; + jint jninewElement_0_step = static_cast(entry_0.step); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0_stepClassName.c_str(), newElement_0_stepCtorSignature.c_str(), jninewElement_0_step, newElement_0_step); + jobject newElement_0_label; + if (!entry_0.label.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_label); + } + else + { + jobject newElement_0_labelInsideOptional; + LogErrorOnFailure( + chip::JniReferences::GetInstance().CharToStringUTF(entry_0.label.Value(), newElement_0_labelInsideOptional)); + chip::JniReferences::GetInstance().CreateOptional(newElement_0_labelInsideOptional, newElement_0_label); + } + + jclass balanceStructStructClass_1; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipStructs$EnergyPreferenceClusterBalanceStruct", balanceStructStructClass_1); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipStructs$EnergyPreferenceClusterBalanceStruct"); + return; + } + jmethodID balanceStructStructCtor_1 = + env->GetMethodID(balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V"); + if (balanceStructStructCtor_1 == nullptr) + { + ChipLogError(Zcl, "Could not find ChipStructs$EnergyPreferenceClusterBalanceStruct constructor"); + return; + } + + newElement_0 = env->NewObject(balanceStructStructClass_1, balanceStructStructCtor_1, newElement_0_step, newElement_0_label); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback(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"); + } +} + +CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::~CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::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/Integer"; + std::string newElement_0CtorSignature = "(I)V"; + jint 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); +} + +CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback( + 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"); + } +} + +CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::~CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::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; + jobject newElement_0_step; + std::string newElement_0_stepClassName = "java/lang/Integer"; + std::string newElement_0_stepCtorSignature = "(I)V"; + jint jninewElement_0_step = static_cast(entry_0.step); + chip::JniReferences::GetInstance().CreateBoxedObject( + newElement_0_stepClassName.c_str(), newElement_0_stepCtorSignature.c_str(), jninewElement_0_step, newElement_0_step); + jobject newElement_0_label; + if (!entry_0.label.HasValue()) + { + chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_label); + } + else + { + jobject newElement_0_labelInsideOptional; + LogErrorOnFailure( + chip::JniReferences::GetInstance().CharToStringUTF(entry_0.label.Value(), newElement_0_labelInsideOptional)); + chip::JniReferences::GetInstance().CreateOptional(newElement_0_labelInsideOptional, newElement_0_label); + } + + jclass balanceStructStructClass_1; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipStructs$EnergyPreferenceClusterBalanceStruct", balanceStructStructClass_1); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipStructs$EnergyPreferenceClusterBalanceStruct"); + return; + } + jmethodID balanceStructStructCtor_1 = + env->GetMethodID(balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V"); + if (balanceStructStructCtor_1 == nullptr) + { + ChipLogError(Zcl, "Could not find ChipStructs$EnergyPreferenceClusterBalanceStruct constructor"); + return; + } + + newElement_0 = env->NewObject(balanceStructStructClass_1, balanceStructStructCtor_1, newElement_0_step, newElement_0_label); + chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); + } + + env->ExceptionClear(); + env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); +} + +CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::CHIPEnergyPreferenceGeneratedCommandListAttributeCallback( + 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"); + } +} + +CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::~CHIPEnergyPreferenceGeneratedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::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); +} + +CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::CHIPEnergyPreferenceAcceptedCommandListAttributeCallback( + 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"); + } +} + +CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::~CHIPEnergyPreferenceAcceptedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::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); +} + +CHIPEnergyPreferenceEventListAttributeCallback::CHIPEnergyPreferenceEventListAttributeCallback(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"); + } +} + +CHIPEnergyPreferenceEventListAttributeCallback::~CHIPEnergyPreferenceEventListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceEventListAttributeCallback::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); +} + +CHIPEnergyPreferenceAttributeListAttributeCallback::CHIPEnergyPreferenceAttributeListAttributeCallback(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"); + } +} + +CHIPEnergyPreferenceAttributeListAttributeCallback::~CHIPEnergyPreferenceAttributeListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyPreferenceAttributeListAttributeCallback::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); +} + CHIPDoorLockLockStateAttributeCallback::CHIPDoorLockLockStateAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index de9f3606fff214..2c5cfc50944076 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -6985,6 +6985,82 @@ class ChipClusters: }, }, } + _ENERGY_PREFERENCE_CLUSTER_INFO = { + "clusterName": "EnergyPreference", + "clusterId": 0x0000009B, + "commands": { + }, + "attributes": { + 0x00000000: { + "attributeName": "EnergyBalances", + "attributeId": 0x00000000, + "type": "", + "reportable": True, + }, + 0x00000001: { + "attributeName": "CurrentEnergyBalance", + "attributeId": 0x00000001, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000002: { + "attributeName": "EnergyPriorities", + "attributeId": 0x00000002, + "type": "int", + "reportable": True, + }, + 0x00000003: { + "attributeName": "LowPowerModeSensitivities", + "attributeId": 0x00000003, + "type": "", + "reportable": True, + }, + 0x00000004: { + "attributeName": "CurrentLowPowerModeSensitivity", + "attributeId": 0x00000004, + "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, + }, + }, + } _DOOR_LOCK_CLUSTER_INFO = { "clusterName": "DoorLock", "clusterId": 0x00000101, @@ -14123,6 +14199,7 @@ class ChipClusters: 0x00000096: _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO, 0x00000098: _DEVICE_ENERGY_MANAGEMENT_CLUSTER_INFO, 0x00000099: _ENERGY_EVSE_CLUSTER_INFO, + 0x0000009B: _ENERGY_PREFERENCE_CLUSTER_INFO, 0x00000101: _DOOR_LOCK_CLUSTER_INFO, 0x00000102: _WINDOW_COVERING_CLUSTER_INFO, 0x00000103: _BARRIER_CONTROL_CLUSTER_INFO, @@ -14238,6 +14315,7 @@ class ChipClusters: "DemandResponseLoadControl": _DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER_INFO, "DeviceEnergyManagement": _DEVICE_ENERGY_MANAGEMENT_CLUSTER_INFO, "EnergyEvse": _ENERGY_EVSE_CLUSTER_INFO, + "EnergyPreference": _ENERGY_PREFERENCE_CLUSTER_INFO, "DoorLock": _DOOR_LOCK_CLUSTER_INFO, "WindowCovering": _WINDOW_COVERING_CLUSTER_INFO, "BarrierControl": _BARRIER_CONTROL_CLUSTER_INFO, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 005038b5ac8230..6cfb1520eb2936 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -24939,6 +24939,248 @@ def descriptor(cls) -> ClusterObjectDescriptor: uid: 'bytes' = b"" +@dataclass +class EnergyPreference(Cluster): + id: typing.ClassVar[int] = 0x0000009B + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="energyBalances", Tag=0x00000000, Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]), + ClusterObjectFieldDescriptor(Label="currentEnergyBalance", Tag=0x00000001, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="energyPriorities", Tag=0x00000002, Type=typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]), + ClusterObjectFieldDescriptor(Label="lowPowerModeSensitivities", Tag=0x00000003, Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]), + ClusterObjectFieldDescriptor(Label="currentLowPowerModeSensitivity", Tag=0x00000004, 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), + ]) + + energyBalances: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None + currentEnergyBalance: 'typing.Optional[uint]' = None + energyPriorities: 'typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]' = None + lowPowerModeSensitivities: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None + currentLowPowerModeSensitivity: '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 EnergyPriorityEnum(MatterIntEnum): + kComfort = 0x00 + kSpeed = 0x01 + kEfficiency = 0x02 + kWaterConsumption = 0x03 + # 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 = 4, + + class Bitmaps: + class Feature(IntFlag): + kEnergyBalance = 0x1 + kLowPowerModeSensitivity = 0x2 + + class Structs: + @dataclass + class BalanceStruct(ClusterObject): + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="step", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="label", Tag=1, Type=typing.Optional[str]), + ]) + + step: 'uint' = 0 + label: 'typing.Optional[str]' = None + + class Attributes: + @dataclass + class EnergyBalances(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0000009B + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]) + + value: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None + + @dataclass + class CurrentEnergyBalance(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0000009B + + @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 EnergyPriorities(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0000009B + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]) + + value: 'typing.Optional[typing.List[EnergyPreference.Enums.EnergyPriorityEnum]]' = None + + @dataclass + class LowPowerModeSensitivities(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0000009B + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]) + + value: 'typing.Optional[typing.List[EnergyPreference.Structs.BalanceStruct]]' = None + + @dataclass + class CurrentLowPowerModeSensitivity(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x0000009B + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000004 + + @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 0x0000009B + + @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 0x0000009B + + @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 0x0000009B + + @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 0x0000009B + + @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 0x0000009B + + @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 0x0000009B + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFD + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass class DoorLock(Cluster): id: typing.ClassVar[int] = 0x00000101 diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm index ecc5f5d7f80a47..61c99664562981 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm @@ -3188,6 +3188,48 @@ static BOOL AttributeIsSpecifiedInEnergyEVSECluster(AttributeId aAttributeId) } } } +static BOOL AttributeIsSpecifiedInEnergyPreferenceCluster(AttributeId aAttributeId) +{ + using namespace Clusters::EnergyPreference; + switch (aAttributeId) { + case Attributes::EnergyBalances::Id: { + return YES; + } + case Attributes::CurrentEnergyBalance::Id: { + return YES; + } + case Attributes::EnergyPriorities::Id: { + return YES; + } + case Attributes::LowPowerModeSensitivities::Id: { + return YES; + } + case Attributes::CurrentLowPowerModeSensitivity::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 AttributeIsSpecifiedInDoorLockCluster(AttributeId aAttributeId) { using namespace Clusters::DoorLock; @@ -6459,6 +6501,9 @@ BOOL MTRAttributeIsSpecified(ClusterId aClusterId, AttributeId aAttributeId) case Clusters::EnergyEvse::Id: { return AttributeIsSpecifiedInEnergyEVSECluster(aAttributeId); } + case Clusters::EnergyPreference::Id: { + return AttributeIsSpecifiedInEnergyPreferenceCluster(aAttributeId); + } case Clusters::DoorLock::Id: { return AttributeIsSpecifiedInDoorLockCluster(aAttributeId); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm index 588e4a533c503c..6308eacacf72f9 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm @@ -8894,6 +8894,140 @@ static id _Nullable DecodeAttributeValueForEnergyEVSECluster(AttributeId aAttrib *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; return nil; } +static id _Nullable DecodeAttributeValueForEnergyPreferenceCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::EnergyPreference; + switch (aAttributeId) { + case Attributes::EnergyBalances::Id: { + using TypeInfo = Attributes::EnergyBalances::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + MTREnergyPreferenceClusterBalanceStruct * newElement_0; + newElement_0 = [MTREnergyPreferenceClusterBalanceStruct new]; + newElement_0.step = [NSNumber numberWithUnsignedChar:entry_0.step]; + if (entry_0.label.HasValue()) { + newElement_0.label = AsString(entry_0.label.Value()); + if (newElement_0.label == nil) { + CHIP_ERROR err = CHIP_ERROR_INVALID_ARGUMENT; + *aError = err; + return nil; + } + } else { + newElement_0.label = nil; + } + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::CurrentEnergyBalance::Id: { + using TypeInfo = Attributes::CurrentEnergyBalance::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:cppValue]; + return value; + } + case Attributes::EnergyPriorities::Id: { + using TypeInfo = Attributes::EnergyPriorities::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedChar:chip::to_underlying(entry_0)]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::LowPowerModeSensitivities::Id: { + using TypeInfo = Attributes::LowPowerModeSensitivities::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + MTREnergyPreferenceClusterBalanceStruct * newElement_0; + newElement_0 = [MTREnergyPreferenceClusterBalanceStruct new]; + newElement_0.step = [NSNumber numberWithUnsignedChar:entry_0.step]; + if (entry_0.label.HasValue()) { + newElement_0.label = AsString(entry_0.label.Value()); + if (newElement_0.label == nil) { + CHIP_ERROR err = CHIP_ERROR_INVALID_ARGUMENT; + *aError = err; + return nil; + } + } else { + newElement_0.label = nil; + } + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::CurrentLowPowerModeSensitivity::Id: { + using TypeInfo = Attributes::CurrentLowPowerModeSensitivity::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedChar:cppValue]; + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + return nil; +} static id _Nullable DecodeAttributeValueForDoorLockCluster(AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::DoorLock; @@ -18541,6 +18675,9 @@ id _Nullable MTRDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::T case Clusters::EnergyEvse::Id: { return DecodeAttributeValueForEnergyEVSECluster(aPath.mAttributeId, aReader, aError); } + case Clusters::EnergyPreference::Id: { + return DecodeAttributeValueForEnergyPreferenceCluster(aPath.mAttributeId, aReader, aError); + } case Clusters::DoorLock::Id: { return DecodeAttributeValueForDoorLockCluster(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 bbf56e5bb8601c..1c3298fb15b308 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -7945,6 +7945,101 @@ MTR_PROVISIONALLY_AVAILABLE @end +/** + * Cluster Energy Preference + * + * This cluster provides an interface to specify preferences for how devices should consume energy. + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRBaseClusterEnergyPreference : MTRGenericBaseCluster + +- (void)readAttributeEnergyBalancesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeEnergyBalancesWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeEnergyBalancesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeCurrentEnergyBalanceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeCurrentEnergyBalanceWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeCurrentEnergyBalanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeEnergyPrioritiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeEnergyPrioritiesWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeEnergyPrioritiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeLowPowerModeSensitivitiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeLowPowerModeSensitivitiesWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeLowPowerModeSensitivitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; + +- (void)readAttributeCurrentLowPowerModeSensitivityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value params:(MTRWriteParams * _Nullable)params completion:(MTRStatusCompletion)completion MTR_PROVISIONALLY_AVAILABLE; +- (void)subscribeAttributeCurrentLowPowerModeSensitivityWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler MTR_PROVISIONALLY_AVAILABLE; ++ (void)readAttributeCurrentLowPowerModeSensitivityWithClusterStateCache:(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 MTRBaseClusterEnergyPreference (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 Door Lock * @@ -17373,6 +17468,18 @@ typedef NS_OPTIONS(uint8_t, MTREnergyEVSETargetDayOfWeekBitmap) { MTREnergyEVSETargetDayOfWeekBitmapSaturday MTR_PROVISIONALLY_AVAILABLE = 0x40, } MTR_PROVISIONALLY_AVAILABLE; +typedef NS_ENUM(uint8_t, MTREnergyPreferenceEnergyPriority) { + MTREnergyPreferenceEnergyPriorityComfort MTR_PROVISIONALLY_AVAILABLE = 0x00, + MTREnergyPreferenceEnergyPrioritySpeed MTR_PROVISIONALLY_AVAILABLE = 0x01, + MTREnergyPreferenceEnergyPriorityEfficiency MTR_PROVISIONALLY_AVAILABLE = 0x02, + MTREnergyPreferenceEnergyPriorityWaterConsumption MTR_PROVISIONALLY_AVAILABLE = 0x03, +} MTR_PROVISIONALLY_AVAILABLE; + +typedef NS_OPTIONS(uint32_t, MTREnergyPreferenceFeature) { + MTREnergyPreferenceFeatureEnergyBalance MTR_PROVISIONALLY_AVAILABLE = 0x1, + MTREnergyPreferenceFeatureLowPowerModeSensitivity MTR_PROVISIONALLY_AVAILABLE = 0x2, +} MTR_PROVISIONALLY_AVAILABLE; + typedef NS_ENUM(uint8_t, MTRDoorLockAlarmCode) { MTRDoorLockAlarmCodeLockJammed MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00, MTRDoorLockAlarmCodeLockFactoryReset MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x01, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm index 3d4fb9799ca6a6..1bda7cb36cd7bf 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm @@ -53268,6 +53268,462 @@ + (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheC @end +@implementation MTRBaseClusterEnergyPreference + +- (void)readAttributeEnergyBalancesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeEnergyBalancesWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeEnergyBalancesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::EnergyBalances::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeCurrentEnergyBalanceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeCurrentEnergyBalanceWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; +} +- (void)writeAttributeCurrentEnergyBalanceWithValue:(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 = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; + TypeInfo::Type cppValue; + cppValue = 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)subscribeAttributeCurrentEnergyBalanceWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeCurrentEnergyBalanceWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::CurrentEnergyBalance::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeEnergyPrioritiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeEnergyPrioritiesWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeEnergyPrioritiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::EnergyPriorities::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeLowPowerModeSensitivitiesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)subscribeAttributeLowPowerModeSensitivitiesWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeLowPowerModeSensitivitiesWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::LowPowerModeSensitivities::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +- (void)readAttributeCurrentLowPowerModeSensitivityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo; + [self.device _readKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:nil + queue:self.callbackQueue + completion:completion]; +} + +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; +} +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(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 = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo; + TypeInfo::Type cppValue; + cppValue = 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)subscribeAttributeCurrentLowPowerModeSensitivityWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::TypeInfo; + [self.device _subscribeToKnownAttributeWithEndpointID:@(self.endpoint) + clusterID:@(TypeInfo::GetClusterId()) + attributeID:@(TypeInfo::GetAttributeId()) + params:params + queue:self.callbackQueue + reportHandler:reportHandler + subscriptionEstablished:subscriptionEstablished]; +} + ++ (void)readAttributeCurrentLowPowerModeSensitivityWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer endpoint:(NSNumber *)endpoint queue:(dispatch_queue_t)queue completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + using TypeInfo = EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::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 = EnergyPreference::Attributes::ClusterRevision::TypeInfo; + [clusterStateCacheContainer + _readKnownCachedAttributeWithEndpointID:static_cast([endpoint unsignedShortValue]) + clusterID:TypeInfo::GetClusterId() + attributeID:TypeInfo::GetAttributeId() + queue:queue + completion:completion]; +} + +@end + @implementation MTRBaseClusterDoorLock - (void)lockDoorWithCompletion:(MTRStatusCompletion)completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index aebafa0f07b881..77e169df653784 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -153,6 +153,7 @@ typedef NS_ENUM(uint32_t, MTRClusterIDType) { MTRClusterIDTypeDemandResponseLoadControlID MTR_PROVISIONALLY_AVAILABLE = 0x00000096, MTRClusterIDTypeDeviceEnergyManagementID MTR_PROVISIONALLY_AVAILABLE = 0x00000098, MTRClusterIDTypeEnergyEVSEID MTR_PROVISIONALLY_AVAILABLE = 0x00000099, + MTRClusterIDTypeEnergyPreferenceID MTR_PROVISIONALLY_AVAILABLE = 0x0000009B, 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, MTRClusterIDTypeBarrierControlID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000103, @@ -2657,6 +2658,19 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterEnergyEVSEAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, MTRAttributeIDTypeClusterEnergyEVSEAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster EnergyPreference attributes + MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyBalancesID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentEnergyBalanceID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyPrioritiesID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeLowPowerModeSensitivitiesID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentLowPowerModeSensitivityID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeGeneratedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeAcceptedCommandListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeEventListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeEventListID, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeAttributeListID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeAttributeListID, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeFeatureMapID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeFeatureMapID, + MTRAttributeIDTypeClusterEnergyPreferenceAttributeClusterRevisionID MTR_PROVISIONALLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster DoorLock deprecated attribute names MTRClusterDoorLockAttributeLockStateID MTR_DEPRECATED("Please use MTRAttributeIDTypeClusterDoorLockAttributeLockStateID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h index e16555ac8d65f8..6fcea80c35673e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h @@ -3730,6 +3730,56 @@ MTR_PROVISIONALLY_AVAILABLE @end +/** + * Cluster Energy Preference + * This cluster provides an interface to specify preferences for how devices should consume energy. + */ +MTR_PROVISIONALLY_AVAILABLE +@interface MTRClusterEnergyPreference : MTRGenericCluster + +- (NSDictionary * _Nullable)readAttributeEnergyBalancesWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeCurrentEnergyBalanceWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeEnergyPrioritiesWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeLowPowerModeSensitivitiesWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; + +- (NSDictionary * _Nullable)readAttributeCurrentLowPowerModeSensitivityWithParams:(MTRReadParams * _Nullable)params MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_PROVISIONALLY_AVAILABLE; +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(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 MTRClusterEnergyPreference (Availability) + +/** + * The queue is currently unused, but may be used in the future for calling completions + * for command invocations if commands are added to this cluster. + */ +- (instancetype _Nullable)initWithDevice:(MTRDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue MTR_PROVISIONALLY_AVAILABLE; + +@end + /** * Cluster Door Lock * An interface to a generic way to secure a door diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm index 0ba4c0c9a54202..7f79d6452d3415 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm @@ -10185,6 +10185,87 @@ - (void)writeAttributeApproximateEVEfficiencyWithValue:(NSDictionary * _Nullable)readAttributeEnergyBalancesWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyBalancesID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeCurrentEnergyBalanceWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentEnergyBalanceID) params:params]; +} + +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeCurrentEnergyBalanceWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeCurrentEnergyBalanceWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentEnergyBalanceID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeEnergyPrioritiesWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeEnergyPrioritiesID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeLowPowerModeSensitivitiesWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeLowPowerModeSensitivitiesID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeCurrentLowPowerModeSensitivityWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentLowPowerModeSensitivityID) params:params]; +} + +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeCurrentLowPowerModeSensitivityWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeCurrentLowPowerModeSensitivityWithValue:(NSDictionary *)dataValueDictionary expectedValueInterval:(NSNumber *)expectedValueIntervalMs params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeCurrentLowPowerModeSensitivityID) value:dataValueDictionary expectedValueInterval:expectedValueIntervalMs timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary * _Nullable)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeGeneratedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeAcceptedCommandListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeEventListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeAttributeListID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeFeatureMapID) params:params]; +} + +- (NSDictionary * _Nullable)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(self.endpoint) clusterID:@(MTRClusterIDTypeEnergyPreferenceID) attributeID:@(MTRAttributeIDTypeClusterEnergyPreferenceAttributeClusterRevisionID) params:params]; +} + +@end + @implementation MTRClusterDoorLock - (void)lockDoorWithExpectedValues:(NSArray *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(MTRStatusCompletion)completion diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm index 6cd8d96b3a2745..caa80fba219adb 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandTimedCheck.mm @@ -647,6 +647,15 @@ static BOOL CommandNeedsTimedInvokeInEnergyEVSECluster(AttributeId aAttributeId) } } } +static BOOL CommandNeedsTimedInvokeInEnergyPreferenceCluster(AttributeId aAttributeId) +{ + using namespace Clusters::EnergyPreference; + switch (aAttributeId) { + default: { + return NO; + } + } +} static BOOL CommandNeedsTimedInvokeInDoorLockCluster(AttributeId aAttributeId) { using namespace Clusters::DoorLock; @@ -1272,6 +1281,9 @@ BOOL MTRCommandNeedsTimedInvoke(NSNumber * _Nonnull aClusterID, NSNumber * _Nonn case Clusters::EnergyEvse::Id: { return CommandNeedsTimedInvokeInEnergyEVSECluster(commandID); } + case Clusters::EnergyPreference::Id: { + return CommandNeedsTimedInvokeInEnergyPreferenceCluster(commandID); + } case Clusters::DoorLock::Id: { return CommandNeedsTimedInvokeInDoorLockCluster(commandID); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index d7c1b50249a15d..119031161f5195 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -3055,6 +3055,18 @@ static id _Nullable DecodeEventPayloadForEnergyEVSECluster(EventId aEventId, TLV *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; return nil; } +static id _Nullable DecodeEventPayloadForEnergyPreferenceCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::EnergyPreference; + switch (aEventId) { + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + return nil; +} static id _Nullable DecodeEventPayloadForDoorLockCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { using namespace Clusters::DoorLock; @@ -4493,6 +4505,9 @@ id _Nullable MTRDecodeEventPayload(const ConcreteEventPath & aPath, TLV::TLVRead case Clusters::EnergyEvse::Id: { return DecodeEventPayloadForEnergyEVSECluster(aPath.mEventId, aReader, aError); } + case Clusters::EnergyPreference::Id: { + return DecodeEventPayloadForEnergyPreferenceCluster(aPath.mEventId, aReader, aError); + } case Clusters::DoorLock::Id: { return DecodeEventPayloadForDoorLockCluster(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 820242a59f0acd..064bd1f321d21e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1325,6 +1325,12 @@ MTR_PROVISIONALLY_AVAILABLE @property (nonatomic, copy) NSData * _Nonnull uid MTR_PROVISIONALLY_AVAILABLE; @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTREnergyPreferenceClusterBalanceStruct : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull step MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSString * _Nullable label MTR_PROVISIONALLY_AVAILABLE; +@end + MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) @interface MTRDoorLockClusterCredentialStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull credentialType MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)); diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index 14a259b78baecb..d8b97ec82d42fa 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -5439,6 +5439,36 @@ - (NSString *)description @end +@implementation MTREnergyPreferenceClusterBalanceStruct +- (instancetype)init +{ + if (self = [super init]) { + + _step = @(0); + + _label = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTREnergyPreferenceClusterBalanceStruct alloc] init]; + + other.step = self.step; + other.label = self.label; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: step:%@; label:%@; >", NSStringFromClass([self class]), _step, _label]; + return descriptionString; +} + +@end + @implementation MTRDoorLockClusterCredentialStruct - (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 49d7459ace3f94..6f3fba5935f84d 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 @@ -10533,6 +10533,136 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) } // namespace Attributes } // namespace EnergyEvse +namespace EnergyPreference { +namespace Attributes { + +namespace CurrentEnergyBalance { + +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::EnergyPreference::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, uint8_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::EnergyPreference::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); +} + +} // namespace CurrentEnergyBalance + +namespace CurrentLowPowerModeSensitivity { + +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::EnergyPreference::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, uint8_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::EnergyPreference::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); +} + +} // namespace CurrentLowPowerModeSensitivity + +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::EnergyPreference::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::EnergyPreference::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::EnergyPreference::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::EnergyPreference::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); +} + +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace EnergyPreference + namespace DoorLock { 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 d30e7984a405ec..2fed842607a66e 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 @@ -2051,6 +2051,32 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Attributes } // namespace EnergyEvse +namespace EnergyPreference { +namespace Attributes { + +namespace CurrentEnergyBalance { +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); +} // namespace CurrentEnergyBalance + +namespace CurrentLowPowerModeSensitivity { +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); +} // namespace CurrentLowPowerModeSensitivity + +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 EnergyPreference + namespace DoorLock { namespace Attributes { 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 a76ef9430a3dc6..fa83804118b175 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 @@ -1784,6 +1784,21 @@ static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyEvse::SupplyState } } +static auto __attribute__((unused)) EnsureKnownEnumValue(EnergyPreference::EnergyPriorityEnum val) +{ + using EnumType = EnergyPreference::EnergyPriorityEnum; + switch (val) + { + case EnumType::kComfort: + case EnumType::kSpeed: + case EnumType::kEfficiency: + case EnumType::kWaterConsumption: + return val; + default: + return static_cast(4); + } +} + static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::AlarmCodeEnum val) { using EnumType = DoorLock::AlarmCodeEnum; 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 1931a6680fffa3..49b66ec661f0eb 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 @@ -2556,6 +2556,30 @@ enum class TargetDayOfWeekBitmap : uint8_t }; } // namespace EnergyEvse +namespace EnergyPreference { + +// Enum for EnergyPriorityEnum +enum class EnergyPriorityEnum : uint8_t +{ + kComfort = 0x00, + kSpeed = 0x01, + kEfficiency = 0x02, + kWaterConsumption = 0x03, + // 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 = 4, +}; + +// Bitmap for Feature +enum class Feature : uint32_t +{ + kEnergyBalance = 0x1, + kLowPowerModeSensitivity = 0x2, +}; +} // namespace EnergyPreference + namespace DoorLock { // Enum for AlarmCodeEnum 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 7603d5c18e39e1..e4988fdd696cd1 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 @@ -16482,6 +16482,89 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Events } // namespace EnergyEvse +namespace EnergyPreference { +namespace Structs { + +namespace BalanceStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + DataModel::WrappedStructEncoder encoder{ aWriter, aTag }; + encoder.Encode(to_underlying(Fields::kStep), step); + encoder.Encode(to_underlying(Fields::kLabel), label); + 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::kStep)) + { + err = DataModel::Decode(reader, step); + } + else if (__context_tag == to_underlying(Fields::kLabel)) + { + err = DataModel::Decode(reader, label); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} + +} // namespace BalanceStruct +} // namespace Structs + +namespace Commands {} // namespace Commands + +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::EnergyBalances::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, energyBalances); + case Attributes::CurrentEnergyBalance::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, currentEnergyBalance); + case Attributes::EnergyPriorities::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, energyPriorities); + case Attributes::LowPowerModeSensitivities::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, lowPowerModeSensitivities); + case Attributes::CurrentLowPowerModeSensitivity::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, currentLowPowerModeSensitivity); + case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, generatedCommandList); + case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, acceptedCommandList); + case Attributes::EventList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, eventList); + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, attributeList); + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, featureMap); + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + return DataModel::Decode(reader, clusterRevision); + default: + return CHIP_NO_ERROR; + } +} +} // namespace Attributes + +namespace Events {} // namespace Events + +} // namespace EnergyPreference namespace DoorLock { namespace Structs { 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 be53c43d05a1a6..e41a226edfbdaa 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 @@ -22993,6 +22993,160 @@ struct DecodableType } // namespace Rfid } // namespace Events } // namespace EnergyEvse +namespace EnergyPreference { +namespace Structs { +namespace BalanceStruct { +enum class Fields : uint8_t +{ + kStep = 0, + kLabel = 1, +}; + +struct Type +{ +public: + chip::Percent step = static_cast(0); + Optional label; + + CHIP_ERROR Decode(TLV::TLVReader & reader); + + static constexpr bool kIsFabricScoped = false; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +using DecodableType = Type; + +} // namespace BalanceStruct +} // namespace Structs + +namespace Attributes { + +namespace EnergyBalances { +struct TypeInfo +{ + using Type = chip::app::DataModel::List; + using DecodableType = + chip::app::DataModel::DecodableList; + using DecodableArgType = + const chip::app::DataModel::DecodableList &; + + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::EnergyBalances::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace EnergyBalances +namespace CurrentEnergyBalance { +struct TypeInfo +{ + using Type = uint8_t; + using DecodableType = uint8_t; + using DecodableArgType = uint8_t; + + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::CurrentEnergyBalance::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace CurrentEnergyBalance +namespace EnergyPriorities { +struct TypeInfo +{ + using Type = chip::app::DataModel::List; + using DecodableType = chip::app::DataModel::DecodableList; + using DecodableArgType = const chip::app::DataModel::DecodableList &; + + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::EnergyPriorities::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace EnergyPriorities +namespace LowPowerModeSensitivities { +struct TypeInfo +{ + using Type = chip::app::DataModel::List; + using DecodableType = + chip::app::DataModel::DecodableList; + using DecodableArgType = + const chip::app::DataModel::DecodableList &; + + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::LowPowerModeSensitivities::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace LowPowerModeSensitivities +namespace CurrentLowPowerModeSensitivity { +struct TypeInfo +{ + using Type = uint8_t; + using DecodableType = uint8_t; + using DecodableArgType = uint8_t; + + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::CurrentLowPowerModeSensitivity::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace CurrentLowPowerModeSensitivity +namespace GeneratedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } +}; +} // namespace GeneratedCommandList +namespace AcceptedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } +}; +} // namespace AcceptedCommandList +namespace EventList { +struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } +}; +} // namespace EventList +namespace AttributeList { +struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } +}; +} // namespace AttributeList +namespace FeatureMap { +struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } +}; +} // namespace FeatureMap +namespace ClusterRevision { +struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } +}; +} // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::EnergyPreference::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::EnergyBalances::TypeInfo::DecodableType energyBalances; + Attributes::CurrentEnergyBalance::TypeInfo::DecodableType currentEnergyBalance = static_cast(0); + Attributes::EnergyPriorities::TypeInfo::DecodableType energyPriorities; + Attributes::LowPowerModeSensitivities::TypeInfo::DecodableType lowPowerModeSensitivities; + Attributes::CurrentLowPowerModeSensitivity::TypeInfo::DecodableType currentLowPowerModeSensitivity = + 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 EnergyPreference namespace DoorLock { namespace Structs { namespace CredentialStruct { 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 4695c568ad375b..62785377b59df5 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 @@ -3969,6 +3969,56 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; } // namespace Attributes } // namespace EnergyEvse +namespace EnergyPreference { +namespace Attributes { + +namespace EnergyBalances { +static constexpr AttributeId Id = 0x00000000; +} // namespace EnergyBalances + +namespace CurrentEnergyBalance { +static constexpr AttributeId Id = 0x00000001; +} // namespace CurrentEnergyBalance + +namespace EnergyPriorities { +static constexpr AttributeId Id = 0x00000002; +} // namespace EnergyPriorities + +namespace LowPowerModeSensitivities { +static constexpr AttributeId Id = 0x00000003; +} // namespace LowPowerModeSensitivities + +namespace CurrentLowPowerModeSensitivity { +static constexpr AttributeId Id = 0x00000004; +} // namespace CurrentLowPowerModeSensitivity + +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 EnergyPreference + namespace DoorLock { 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 c27144ce2d58f3..22c0372ff8208b 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 @@ -232,6 +232,9 @@ static constexpr ClusterId Id = 0x00000098; namespace EnergyEvse { static constexpr ClusterId Id = 0x00000099; } // namespace EnergyEvse +namespace EnergyPreference { +static constexpr ClusterId Id = 0x0000009B; +} // namespace EnergyPreference namespace DoorLock { static constexpr ClusterId Id = 0x00000101; } // namespace DoorLock 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 717678971f45de..ff759011ffad1c 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 @@ -471,6 +471,12 @@ #define CHIP_PRINTCLUSTER_ENERGY_EVSE_CLUSTER #endif +#if defined(ZCL_USING_ENERGY_PREFERENCE_CLUSTER_SERVER) || defined(ZCL_USING_ENERGY_PREFERENCE_CLUSTER_CLIENT) +#define CHIP_PRINTCLUSTER_ENERGY_PREFERENCE_CLUSTER { chip::app::Clusters::EnergyPreference::Id, "Energy Preference" }, +#else +#define CHIP_PRINTCLUSTER_ENERGY_PREFERENCE_CLUSTER +#endif + #if defined(ZCL_USING_DOOR_LOCK_CLUSTER_SERVER) || defined(ZCL_USING_DOOR_LOCK_CLUSTER_CLIENT) #define CHIP_PRINTCLUSTER_DOOR_LOCK_CLUSTER { chip::app::Clusters::DoorLock::Id, "Door Lock" }, #else @@ -829,6 +835,7 @@ CHIP_PRINTCLUSTER_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER \ CHIP_PRINTCLUSTER_DEVICE_ENERGY_MANAGEMENT_CLUSTER \ CHIP_PRINTCLUSTER_ENERGY_EVSE_CLUSTER \ + CHIP_PRINTCLUSTER_ENERGY_PREFERENCE_CLUSTER \ CHIP_PRINTCLUSTER_DOOR_LOCK_CLUSTER \ CHIP_PRINTCLUSTER_WINDOW_COVERING_CLUSTER \ CHIP_PRINTCLUSTER_BARRIER_CONTROL_CLUSTER \ diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index b2cd6d369415c1..c1e1d69f59d802 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -104,6 +104,7 @@ | DemandResponseLoadControl | 0x0096 | | DeviceEnergyManagement | 0x0098 | | EnergyEvse | 0x0099 | +| EnergyPreference | 0x009B | | DoorLock | 0x0101 | | WindowCovering | 0x0102 | | BarrierControl | 0x0103 | @@ -7474,6 +7475,27 @@ class EnergyEvseClearTargets : public ClusterCommand chip::app::Clusters::EnergyEvse::Commands::ClearTargets::Type mRequest; }; +/*----------------------------------------------------------------------------*\ +| Cluster EnergyPreference | 0x009B | +|------------------------------------------------------------------------------| +| Commands: | | +|------------------------------------------------------------------------------| +| Attributes: | | +| * EnergyBalances | 0x0000 | +| * CurrentEnergyBalance | 0x0001 | +| * EnergyPriorities | 0x0002 | +| * LowPowerModeSensitivities | 0x0003 | +| * CurrentLowPowerModeSensitivity | 0x0004 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +\*----------------------------------------------------------------------------*/ + /*----------------------------------------------------------------------------*\ | Cluster DoorLock | 0x0101 | |------------------------------------------------------------------------------| @@ -20357,6 +20379,86 @@ void registerClusterEnergyEvse(Commands & commands, CredentialIssuerCommands * c commands.RegisterCluster(clusterName, clusterCommands); } +void registerClusterEnergyPreference(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) +{ + using namespace chip::app::Clusters::EnergyPreference; + + const char * clusterName = "EnergyPreference"; + + commands_list clusterCommands = { + // + // Commands + // + make_unique(Id, credsIssuerConfig), // + // + // Attributes + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "energy-balances", Attributes::EnergyBalances::Id, credsIssuerConfig), // + make_unique(Id, "current-energy-balance", Attributes::CurrentEnergyBalance::Id, credsIssuerConfig), // + make_unique(Id, "energy-priorities", Attributes::EnergyPriorities::Id, credsIssuerConfig), // + make_unique(Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, + credsIssuerConfig), // + make_unique(Id, "current-low-power-mode-sensitivity", Attributes::CurrentLowPowerModeSensitivity::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, "energy-balances", Attributes::EnergyBalances::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "current-energy-balance", 0, UINT8_MAX, Attributes::CurrentEnergyBalance::Id, + WriteCommandType::kWrite, credsIssuerConfig), // + make_unique< + WriteAttributeAsComplex>>( + Id, "energy-priorities", Attributes::EnergyPriorities::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>(Id, "current-low-power-mode-sensitivity", 0, UINT8_MAX, + Attributes::CurrentLowPowerModeSensitivity::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, "energy-balances", Attributes::EnergyBalances::Id, credsIssuerConfig), // + make_unique(Id, "current-energy-balance", Attributes::CurrentEnergyBalance::Id, credsIssuerConfig), // + make_unique(Id, "energy-priorities", Attributes::EnergyPriorities::Id, credsIssuerConfig), // + make_unique(Id, "low-power-mode-sensitivities", Attributes::LowPowerModeSensitivities::Id, + credsIssuerConfig), // + make_unique(Id, "current-low-power-mode-sensitivity", Attributes::CurrentLowPowerModeSensitivity::Id, + credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + // + // Events + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + }; + + commands.RegisterCluster(clusterName, clusterCommands); +} void registerClusterDoorLock(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) { using namespace chip::app::Clusters::DoorLock; @@ -26058,6 +26160,7 @@ void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssue registerClusterDemandResponseLoadControl(commands, credsIssuerConfig); registerClusterDeviceEnergyManagement(commands, credsIssuerConfig); registerClusterEnergyEvse(commands, credsIssuerConfig); + registerClusterEnergyPreference(commands, credsIssuerConfig); registerClusterDoorLock(commands, credsIssuerConfig); registerClusterWindowCovering(commands, credsIssuerConfig); registerClusterBarrierControl(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 e1f6467987dd2c..d38c78eded3f2b 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -2891,6 +2891,31 @@ 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 chip::app::Clusters::EnergyPreference::Structs::BalanceStruct::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = LogValue("Step", indent + 1, value.step); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Step'"); + return err; + } + } + { + CHIP_ERROR err = LogValue("Label", indent + 1, value.label); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Struct truncated due to invalid value for 'Label'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} + CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const chip::app::Clusters::DoorLock::Structs::CredentialStruct::DecodableType & value) { @@ -12425,6 +12450,67 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP } break; } + case EnergyPreference::Id: { + switch (path.mAttributeId) + { + case EnergyPreference::Attributes::EnergyBalances::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EnergyBalances", 1, value); + } + case EnergyPreference::Attributes::CurrentEnergyBalance::Id: { + uint8_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("CurrentEnergyBalance", 1, value); + } + case EnergyPreference::Attributes::EnergyPriorities::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EnergyPriorities", 1, value); + } + case EnergyPreference::Attributes::LowPowerModeSensitivities::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("LowPowerModeSensitivities", 1, value); + } + case EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::Id: { + uint8_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("CurrentLowPowerModeSensitivity", 1, value); + } + case EnergyPreference::Attributes::GeneratedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("GeneratedCommandList", 1, value); + } + case EnergyPreference::Attributes::AcceptedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AcceptedCommandList", 1, value); + } + case EnergyPreference::Attributes::EventList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EventList", 1, value); + } + case EnergyPreference::Attributes::AttributeList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AttributeList", 1, value); + } + case EnergyPreference::Attributes::FeatureMap::Id: { + uint32_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("FeatureMap", 1, value); + } + case EnergyPreference::Attributes::ClusterRevision::Id: { + uint16_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ClusterRevision", 1, value); + } + } + break; + } case DoorLock::Id: { switch (path.mAttributeId) { 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 2c50faa6194c2f..49fd07683ab36e 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -106,6 +106,7 @@ | DemandResponseLoadControl | 0x0096 | | DeviceEnergyManagement | 0x0098 | | EnergyEvse | 0x0099 | +| EnergyPreference | 0x009B | | DoorLock | 0x0101 | | WindowCovering | 0x0102 | | BarrierControl | 0x0103 | @@ -84362,6 +84363,1046 @@ class SubscribeAttributeEnergyEvseClusterRevision : public SubscribeAttribute { } }; +#endif // MTR_ENABLE_PROVISIONAL +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL +/*----------------------------------------------------------------------------*\ +| Cluster EnergyPreference | 0x009B | +|------------------------------------------------------------------------------| +| Commands: | | +|------------------------------------------------------------------------------| +| Attributes: | | +| * EnergyBalances | 0x0000 | +| * CurrentEnergyBalance | 0x0001 | +| * EnergyPriorities | 0x0002 | +| * LowPowerModeSensitivities | 0x0003 | +| * CurrentLowPowerModeSensitivity | 0x0004 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +\*----------------------------------------------------------------------------*/ + +#if MTR_ENABLE_PROVISIONAL + +/* + * Attribute EnergyBalances + */ +class ReadEnergyPreferenceEnergyBalances : public ReadAttribute { +public: + ReadEnergyPreferenceEnergyBalances() + : ReadAttribute("energy-balances") + { + } + + ~ReadEnergyPreferenceEnergyBalances() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyBalances::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeEnergyBalancesWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.EnergyBalances response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference EnergyBalances read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceEnergyBalances : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceEnergyBalances() + : SubscribeAttribute("energy-balances") + { + } + + ~SubscribeAttributeEnergyPreferenceEnergyBalances() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyBalances::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeEnergyBalancesWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.EnergyBalances 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 CurrentEnergyBalance + */ +class ReadEnergyPreferenceCurrentEnergyBalance : public ReadAttribute { +public: + ReadEnergyPreferenceCurrentEnergyBalance() + : ReadAttribute("current-energy-balance") + { + } + + ~ReadEnergyPreferenceCurrentEnergyBalance() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentEnergyBalance::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeCurrentEnergyBalanceWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.CurrentEnergyBalance response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference CurrentEnergyBalance read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteEnergyPreferenceCurrentEnergyBalance : public WriteAttribute { +public: + WriteEnergyPreferenceCurrentEnergyBalance() + : WriteAttribute("current-energy-balance") + { + AddArgument("attr-name", "current-energy-balance"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteEnergyPreferenceCurrentEnergyBalance() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentEnergyBalance::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 = [[MTRBaseClusterEnergyPreference 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 writeAttributeCurrentEnergyBalanceWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("EnergyPreference CurrentEnergyBalance write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + uint8_t mValue; +}; + +class SubscribeAttributeEnergyPreferenceCurrentEnergyBalance : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceCurrentEnergyBalance() + : SubscribeAttribute("current-energy-balance") + { + } + + ~SubscribeAttributeEnergyPreferenceCurrentEnergyBalance() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentEnergyBalance::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeCurrentEnergyBalanceWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.CurrentEnergyBalance 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 EnergyPriorities + */ +class ReadEnergyPreferenceEnergyPriorities : public ReadAttribute { +public: + ReadEnergyPreferenceEnergyPriorities() + : ReadAttribute("energy-priorities") + { + } + + ~ReadEnergyPreferenceEnergyPriorities() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyPriorities::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeEnergyPrioritiesWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.EnergyPriorities response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference EnergyPriorities read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceEnergyPriorities : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceEnergyPriorities() + : SubscribeAttribute("energy-priorities") + { + } + + ~SubscribeAttributeEnergyPreferenceEnergyPriorities() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::EnergyPriorities::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeEnergyPrioritiesWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.EnergyPriorities 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 LowPowerModeSensitivities + */ +class ReadEnergyPreferenceLowPowerModeSensitivities : public ReadAttribute { +public: + ReadEnergyPreferenceLowPowerModeSensitivities() + : ReadAttribute("low-power-mode-sensitivities") + { + } + + ~ReadEnergyPreferenceLowPowerModeSensitivities() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::LowPowerModeSensitivities::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeLowPowerModeSensitivitiesWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.LowPowerModeSensitivities response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference LowPowerModeSensitivities read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceLowPowerModeSensitivities : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceLowPowerModeSensitivities() + : SubscribeAttribute("low-power-mode-sensitivities") + { + } + + ~SubscribeAttributeEnergyPreferenceLowPowerModeSensitivities() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::LowPowerModeSensitivities::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeLowPowerModeSensitivitiesWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.LowPowerModeSensitivities 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 CurrentLowPowerModeSensitivity + */ +class ReadEnergyPreferenceCurrentLowPowerModeSensitivity : public ReadAttribute { +public: + ReadEnergyPreferenceCurrentLowPowerModeSensitivity() + : ReadAttribute("current-low-power-mode-sensitivity") + { + } + + ~ReadEnergyPreferenceCurrentLowPowerModeSensitivity() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeCurrentLowPowerModeSensitivityWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.CurrentLowPowerModeSensitivity response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference CurrentLowPowerModeSensitivity read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteEnergyPreferenceCurrentLowPowerModeSensitivity : public WriteAttribute { +public: + WriteEnergyPreferenceCurrentLowPowerModeSensitivity() + : WriteAttribute("current-low-power-mode-sensitivity") + { + AddArgument("attr-name", "current-low-power-mode-sensitivity"); + AddArgument("attr-value", 0, UINT8_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteEnergyPreferenceCurrentLowPowerModeSensitivity() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = [[MTRBaseClusterEnergyPreference 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 writeAttributeCurrentLowPowerModeSensitivityWithValue:value params:params completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("EnergyPreference CurrentLowPowerModeSensitivity write Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + uint8_t mValue; +}; + +class SubscribeAttributeEnergyPreferenceCurrentLowPowerModeSensitivity : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceCurrentLowPowerModeSensitivity() + : SubscribeAttribute("current-low-power-mode-sensitivity") + { + } + + ~SubscribeAttributeEnergyPreferenceCurrentLowPowerModeSensitivity() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::Attributes::CurrentLowPowerModeSensitivity::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 = [[MTRBaseClusterEnergyPreference 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 subscribeAttributeCurrentLowPowerModeSensitivityWithParams:params + subscriptionEstablished:^() { mSubscriptionEstablished = YES; } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.CurrentLowPowerModeSensitivity 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 ReadEnergyPreferenceGeneratedCommandList : public ReadAttribute { +public: + ReadEnergyPreferenceGeneratedCommandList() + : ReadAttribute("generated-command-list") + { + } + + ~ReadEnergyPreferenceGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.GeneratedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference GeneratedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceGeneratedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceGeneratedCommandList() + : SubscribeAttribute("generated-command-list") + { + } + + ~SubscribeAttributeEnergyPreferenceGeneratedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceAcceptedCommandList : public ReadAttribute { +public: + ReadEnergyPreferenceAcceptedCommandList() + : ReadAttribute("accepted-command-list") + { + } + + ~ReadEnergyPreferenceAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.AcceptedCommandList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference AcceptedCommandList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceAcceptedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceAcceptedCommandList() + : SubscribeAttribute("accepted-command-list") + { + } + + ~SubscribeAttributeEnergyPreferenceAcceptedCommandList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceEventList : public ReadAttribute { +public: + ReadEnergyPreferenceEventList() + : ReadAttribute("event-list") + { + } + + ~ReadEnergyPreferenceEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.EventList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference EventList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceEventList : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceEventList() + : SubscribeAttribute("event-list") + { + } + + ~SubscribeAttributeEnergyPreferenceEventList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceAttributeList : public ReadAttribute { +public: + ReadEnergyPreferenceAttributeList() + : ReadAttribute("attribute-list") + { + } + + ~ReadEnergyPreferenceAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.AttributeList response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference AttributeList read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceAttributeList : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceAttributeList() + : SubscribeAttribute("attribute-list") + { + } + + ~SubscribeAttributeEnergyPreferenceAttributeList() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceFeatureMap : public ReadAttribute { +public: + ReadEnergyPreferenceFeatureMap() + : ReadAttribute("feature-map") + { + } + + ~ReadEnergyPreferenceFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.FeatureMap response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference FeatureMap read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceFeatureMap : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceFeatureMap() + : SubscribeAttribute("feature-map") + { + } + + ~SubscribeAttributeEnergyPreferenceFeatureMap() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 ReadEnergyPreferenceClusterRevision : public ReadAttribute { +public: + ReadEnergyPreferenceClusterRevision() + : ReadAttribute("cluster-revision") + { + } + + ~ReadEnergyPreferenceClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::AttributeId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference alloc] initWithDevice:device endpointID:@(endpointId) queue:callbackQueue]; + [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"EnergyPreference.ClusterRevision response %@", [value description]); + if (error == nil) { + RemoteDataModelLogger::LogAttributeAsJSON(@(endpointId), @(clusterId), @(attributeId), value); + } else { + LogNSError("EnergyPreference ClusterRevision read Error", error); + RemoteDataModelLogger::LogAttributeErrorAsJSON(@(endpointId), @(clusterId), @(attributeId), error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeEnergyPreferenceClusterRevision : public SubscribeAttribute { +public: + SubscribeAttributeEnergyPreferenceClusterRevision() + : SubscribeAttribute("cluster-revision") + { + } + + ~SubscribeAttributeEnergyPreferenceClusterRevision() + { + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + constexpr chip::ClusterId clusterId = chip::app::Clusters::EnergyPreference::Id; + constexpr chip::CommandId attributeId = chip::app::Clusters::EnergyPreference::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 = [[MTRBaseClusterEnergyPreference 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(@"EnergyPreference.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 /*----------------------------------------------------------------------------*\ @@ -180642,6 +181683,69 @@ void registerClusterEnergyEvse(Commands & commands) commands.RegisterCluster(clusterName, clusterCommands); #endif // MTR_ENABLE_PROVISIONAL } +void registerClusterEnergyPreference(Commands & commands) +{ +#if MTR_ENABLE_PROVISIONAL + using namespace chip::app::Clusters::EnergyPreference; + + const char * clusterName = "EnergyPreference"; + + commands_list clusterCommands = { + make_unique(Id), // + make_unique(Id), // + make_unique(Id), // + make_unique(Id), // +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // +#endif // MTR_ENABLE_PROVISIONAL +#if MTR_ENABLE_PROVISIONAL + make_unique(), // + make_unique(), // + 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 + }; + + commands.RegisterCluster(clusterName, clusterCommands); +#endif // MTR_ENABLE_PROVISIONAL +} void registerClusterDoorLock(Commands & commands) { using namespace chip::app::Clusters::DoorLock; @@ -184096,6 +185200,7 @@ void registerClusters(Commands & commands) registerClusterDemandResponseLoadControl(commands); registerClusterDeviceEnergyManagement(commands); registerClusterEnergyEvse(commands); + registerClusterEnergyPreference(commands); registerClusterDoorLock(commands); registerClusterWindowCovering(commands); registerClusterBarrierControl(commands); From d2d4de4602216176c6ae32ab1e7780a3fc76723d Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Wed, 20 Dec 2023 23:55:23 -0600 Subject: [PATCH 04/26] rerun zap tool on data_model --- .../data_model/controller-clusters.zap | 58 +++++++++---------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 78ff3188a4be5b..e07793b550531d 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -17,12 +17,6 @@ } ], "package": [ - { - "pathRelativity": "relativeToZap", - "path": "../../app/zap-templates/app-templates.json", - "type": "gen-templates-json", - "version": "chip-v1" - }, { "pathRelativity": "relativeToZap", "path": "../../app/zap-templates/zcl/zcl.json", @@ -30,6 +24,12 @@ "category": "matter", "version": 1, "description": "Matter SDK ZCL data" + }, + { + "pathRelativity": "relativeToZap", + "path": "../../app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" } ], "endpointTypes": [ @@ -601,7 +601,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": null, "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -653,7 +653,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -1289,7 +1289,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -1841,7 +1841,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": null, "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -2177,7 +2177,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2237,7 +2237,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2339,7 +2339,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2399,7 +2399,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2553,7 +2553,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2595,7 +2595,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2726,7 +2726,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2947,7 +2947,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -2989,7 +2989,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -3904,7 +3904,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -3946,7 +3946,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -3988,7 +3988,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4030,7 +4030,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4072,7 +4072,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4114,7 +4114,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4156,7 +4156,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4198,7 +4198,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4240,7 +4240,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -4282,7 +4282,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, From 78a484e140c12af3e4f433ab9132afb0c47f0923 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Thu, 21 Dec 2023 05:55:52 +0000 Subject: [PATCH 05/26] Restyled by clang-format --- .../include/oven-operational-state-delegate.h | 8 ++++---- .../src/oven-operational-state-delegate.cpp | 20 +++++++++---------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index aa33602816e485..70e825a7f64905 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -53,10 +53,10 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate OperationalState::GenericOperationalPhase(DataModel::Nullable()), }; - //RvcDevice * mPauseRvcDeviceInstance; - //HandleOpStateCommand mPauseCallback; - //RvcDevice * mResumeRvcDeviceInstance; - //HandleOpStateCommand mResumeCallback; + // RvcDevice * mPauseRvcDeviceInstance; + // HandleOpStateCommand mPauseCallback; + // RvcDevice * mResumeRvcDeviceInstance; + // HandleOpStateCommand mResumeCallback; public: /** diff --git a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp index 9c5e0d10e64cf0..5ca088e12fb4ad 100644 --- a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp @@ -22,7 +22,7 @@ using namespace chip::app; using namespace chip::app::Clusters; using namespace chip::app::Clusters::OvenCavityOperationalState; -static OperationalState::Instance * gOvenCavityOperationalStateInstance = nullptr; +static OperationalState::Instance * gOvenCavityOperationalStateInstance = nullptr; static OvenCavityOperationalStateDelegate * gOvenCavityOperationalStateDelegate = nullptr; void OvenCavityOperationalState::Shutdown() @@ -44,18 +44,19 @@ void emberAfOvenCavityOperationalStateClusterInitCallback(chip::EndpointId endpo VerifyOrDie(endpointId == 1); // this cluster is only enabled for endpoint 1. VerifyOrDie(gOvenCavityOperationalStateInstance == nullptr && gOvenCavityOperationalStateDelegate == nullptr); - gOvenCavityOperationalStateDelegate = new OvenCavityOperationalStateDelegate; + gOvenCavityOperationalStateDelegate = new OvenCavityOperationalStateDelegate; EndpointId operationalStateEndpoint = 0x01; - gOvenCavityOperationalStateInstance = new OvenCavityOperationalState::Instance(gOvenCavityOperationalStateDelegate, operationalStateEndpoint); + gOvenCavityOperationalStateInstance = + new OvenCavityOperationalState::Instance(gOvenCavityOperationalStateDelegate, operationalStateEndpoint); gOvenCavityOperationalStateInstance->SetOperationalState(to_underlying(OperationalState::OperationalStateEnum::kStopped)); gOvenCavityOperationalStateInstance->Init(); } - -CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalStateAtIndex(size_t index, - OperationalState::GenericOperationalState & operationalState) +CHIP_ERROR +OvenCavityOperationalStateDelegate::GetOperationalStateAtIndex(size_t index, + OperationalState::GenericOperationalState & operationalState) { if (index >= ArraySize(mOperationalStateList)) { @@ -65,8 +66,9 @@ CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalStateAtIndex(size_t return CHIP_NO_ERROR; } -CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, - OperationalState::GenericOperationalPhase & operationalPhase) +CHIP_ERROR +OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, + OperationalState::GenericOperationalPhase & operationalPhase) { if (index >= ArraySize(mOperationalPhaseList)) { @@ -76,8 +78,6 @@ CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t return CHIP_NO_ERROR; } - - // void RvcOperationalStateDelegate::HandlePauseStateCallback(OperationalState::GenericOperationalError & err) // { // (mPauseRvcDeviceInstance->*mPauseCallback)(err); From 67a3f75ac947e869d074cb3a9a258158ad687c9d Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Thu, 21 Dec 2023 09:46:38 -0600 Subject: [PATCH 06/26] CLEAN zap-regen-all --- ...nalStateClusterOperationCompletionEvent.kt | 106 - ...tionalStateClusterOperationalErrorEvent.kt | 61 - ...OperationalStateClusterErrorStateStruct.kt | 85 - ...ionalStateClusterOperationalStateStruct.kt | 74 - ...nalStateClusterOperationCompletionEvent.kt | 106 - ...tionalStateClusterOperationalErrorEvent.kt | 62 - ...OperationalStateClusterErrorStateStruct.kt | 85 - ...ionalStateClusterOperationalStateStruct.kt | 74 - .../clusters/OvenOperationalStateCluster.kt | 211 - .../matter/devicecontroller/cluster/files.gni | 252 - .../chip/devicecontroller/ChipClusters.java | 40491 ---------------- 11 files changed, 41607 deletions(-) delete mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt delete mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt delete mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt delete mode 100644 src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt delete mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt delete mode 100644 src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt delete mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt delete mode 100644 src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt delete mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt delete mode 100644 src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni delete mode 100644 src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt deleted file mode 100644 index cf6ceebf5d48fd..00000000000000 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt +++ /dev/null @@ -1,106 +0,0 @@ -/* - * - * 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 OvenOperationalStateClusterOperationCompletionEvent( - val completionErrorCode: UInt, - val totalOperationalTime: Optional?, - val pausedTime: Optional? -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterOperationCompletionEvent {\n") - append("\tcompletionErrorCode : $completionErrorCode\n") - append("\ttotalOperationalTime : $totalOperationalTime\n") - append("\tpausedTime : $pausedTime\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - put(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE), completionErrorCode) - if (totalOperationalTime != null) { - if (totalOperationalTime.isPresent) { - val opttotalOperationalTime = totalOperationalTime.get() - put(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME), opttotalOperationalTime) - } - } else { - putNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) - } - if (pausedTime != null) { - if (pausedTime.isPresent) { - val optpausedTime = pausedTime.get() - put(ContextSpecificTag(TAG_PAUSED_TIME), optpausedTime) - } - } else { - putNull(ContextSpecificTag(TAG_PAUSED_TIME)) - } - endStructure() - } - } - - companion object { - private const val TAG_COMPLETION_ERROR_CODE = 0 - private const val TAG_TOTAL_OPERATIONAL_TIME = 1 - private const val TAG_PAUSED_TIME = 2 - - fun fromTlv( - tlvTag: Tag, - tlvReader: TlvReader - ): OvenOperationalStateClusterOperationCompletionEvent { - tlvReader.enterStructure(tlvTag) - val completionErrorCode = tlvReader.getUInt(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE)) - val totalOperationalTime = - if (!tlvReader.isNull()) { - if (tlvReader.isNextTag(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) { - Optional.of(tlvReader.getULong(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) - } else { - Optional.empty() - } - } else { - tlvReader.getNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) - null - } - val pausedTime = - if (!tlvReader.isNull()) { - if (tlvReader.isNextTag(ContextSpecificTag(TAG_PAUSED_TIME))) { - Optional.of(tlvReader.getULong(ContextSpecificTag(TAG_PAUSED_TIME))) - } else { - Optional.empty() - } - } else { - tlvReader.getNull(ContextSpecificTag(TAG_PAUSED_TIME)) - null - } - - tlvReader.exitContainer() - - return OvenOperationalStateClusterOperationCompletionEvent( - completionErrorCode, - totalOperationalTime, - pausedTime - ) - } - } -} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt deleted file mode 100644 index 45252fa6422863..00000000000000 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt +++ /dev/null @@ -1,61 +0,0 @@ -/* - * - * 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 OvenOperationalStateClusterOperationalErrorEvent( - val errorState: chip.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterOperationalErrorEvent {\n") - append("\terrorState : $errorState\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - errorState.toTlv(ContextSpecificTag(TAG_ERROR_STATE), this) - endStructure() - } - } - - companion object { - private const val TAG_ERROR_STATE = 0 - - fun fromTlv( - tlvTag: Tag, - tlvReader: TlvReader - ): OvenOperationalStateClusterOperationalErrorEvent { - tlvReader.enterStructure(tlvTag) - val errorState = - chip.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct.fromTlv( - ContextSpecificTag(TAG_ERROR_STATE), - tlvReader - ) - - tlvReader.exitContainer() - - return OvenOperationalStateClusterOperationalErrorEvent(errorState) - } - } -} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt deleted file mode 100644 index ffe36aeb938a8a..00000000000000 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt +++ /dev/null @@ -1,85 +0,0 @@ -/* - * - * Copyright (c) 2023 Project CHIP Authors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package chip.devicecontroller.cluster.structs - -import chip.devicecontroller.cluster.* -import java.util.Optional -import matter.tlv.ContextSpecificTag -import matter.tlv.Tag -import matter.tlv.TlvReader -import matter.tlv.TlvWriter - -class OvenOperationalStateClusterErrorStateStruct( - val errorStateID: UInt, - val errorStateLabel: Optional, - val errorStateDetails: Optional -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterErrorStateStruct {\n") - append("\terrorStateID : $errorStateID\n") - append("\terrorStateLabel : $errorStateLabel\n") - append("\terrorStateDetails : $errorStateDetails\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - put(ContextSpecificTag(TAG_ERROR_STATE_I_D), errorStateID) - if (errorStateLabel.isPresent) { - val opterrorStateLabel = errorStateLabel.get() - put(ContextSpecificTag(TAG_ERROR_STATE_LABEL), opterrorStateLabel) - } - if (errorStateDetails.isPresent) { - val opterrorStateDetails = errorStateDetails.get() - put(ContextSpecificTag(TAG_ERROR_STATE_DETAILS), opterrorStateDetails) - } - endStructure() - } - } - - companion object { - private const val TAG_ERROR_STATE_I_D = 0 - private const val TAG_ERROR_STATE_LABEL = 1 - private const val TAG_ERROR_STATE_DETAILS = 2 - - fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): OvenOperationalStateClusterErrorStateStruct { - tlvReader.enterStructure(tlvTag) - val errorStateID = tlvReader.getUInt(ContextSpecificTag(TAG_ERROR_STATE_I_D)) - val errorStateLabel = - if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) { - Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) - } else { - Optional.empty() - } - val errorStateDetails = - if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) { - Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) - } else { - Optional.empty() - } - - tlvReader.exitContainer() - - return OvenOperationalStateClusterErrorStateStruct( - errorStateID, - errorStateLabel, - errorStateDetails - ) - } - } -} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt deleted file mode 100644 index 1e68f9d3a6339c..00000000000000 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt +++ /dev/null @@ -1,74 +0,0 @@ -/* - * - * Copyright (c) 2023 Project CHIP Authors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package chip.devicecontroller.cluster.structs - -import chip.devicecontroller.cluster.* -import java.util.Optional -import matter.tlv.ContextSpecificTag -import matter.tlv.Tag -import matter.tlv.TlvReader -import matter.tlv.TlvWriter - -class OvenOperationalStateClusterOperationalStateStruct( - val operationalStateID: UInt, - val operationalStateLabel: Optional -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterOperationalStateStruct {\n") - append("\toperationalStateID : $operationalStateID\n") - append("\toperationalStateLabel : $operationalStateLabel\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - put(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D), operationalStateID) - if (operationalStateLabel.isPresent) { - val optoperationalStateLabel = operationalStateLabel.get() - put(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL), optoperationalStateLabel) - } - endStructure() - } - } - - companion object { - private const val TAG_OPERATIONAL_STATE_I_D = 0 - private const val TAG_OPERATIONAL_STATE_LABEL = 1 - - fun fromTlv( - tlvTag: Tag, - tlvReader: TlvReader - ): OvenOperationalStateClusterOperationalStateStruct { - tlvReader.enterStructure(tlvTag) - val operationalStateID = tlvReader.getUInt(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D)) - val operationalStateLabel = - if (tlvReader.isNextTag(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) { - Optional.of(tlvReader.getString(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) - } else { - Optional.empty() - } - - tlvReader.exitContainer() - - return OvenOperationalStateClusterOperationalStateStruct( - operationalStateID, - operationalStateLabel - ) - } - } -} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt deleted file mode 100644 index 48ae3a43e7d850..00000000000000 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt +++ /dev/null @@ -1,106 +0,0 @@ -/* - * - * 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 OvenOperationalStateClusterOperationCompletionEvent( - val completionErrorCode: UInt, - val totalOperationalTime: Optional?, - val pausedTime: Optional? -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterOperationCompletionEvent {\n") - append("\tcompletionErrorCode : $completionErrorCode\n") - append("\ttotalOperationalTime : $totalOperationalTime\n") - append("\tpausedTime : $pausedTime\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - put(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE), completionErrorCode) - if (totalOperationalTime != null) { - if (totalOperationalTime.isPresent) { - val opttotalOperationalTime = totalOperationalTime.get() - put(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME), opttotalOperationalTime) - } - } else { - putNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) - } - if (pausedTime != null) { - if (pausedTime.isPresent) { - val optpausedTime = pausedTime.get() - put(ContextSpecificTag(TAG_PAUSED_TIME), optpausedTime) - } - } else { - putNull(ContextSpecificTag(TAG_PAUSED_TIME)) - } - endStructure() - } - } - - companion object { - private const val TAG_COMPLETION_ERROR_CODE = 0 - private const val TAG_TOTAL_OPERATIONAL_TIME = 1 - private const val TAG_PAUSED_TIME = 2 - - fun fromTlv( - tlvTag: Tag, - tlvReader: TlvReader - ): OvenOperationalStateClusterOperationCompletionEvent { - tlvReader.enterStructure(tlvTag) - val completionErrorCode = tlvReader.getUInt(ContextSpecificTag(TAG_COMPLETION_ERROR_CODE)) - val totalOperationalTime = - if (!tlvReader.isNull()) { - if (tlvReader.isNextTag(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) { - Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME))) - } else { - Optional.empty() - } - } else { - tlvReader.getNull(ContextSpecificTag(TAG_TOTAL_OPERATIONAL_TIME)) - null - } - val pausedTime = - if (!tlvReader.isNull()) { - if (tlvReader.isNextTag(ContextSpecificTag(TAG_PAUSED_TIME))) { - Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_PAUSED_TIME))) - } else { - Optional.empty() - } - } else { - tlvReader.getNull(ContextSpecificTag(TAG_PAUSED_TIME)) - null - } - - tlvReader.exitContainer() - - return OvenOperationalStateClusterOperationCompletionEvent( - completionErrorCode, - totalOperationalTime, - pausedTime - ) - } - } -} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt deleted file mode 100644 index 2a5615a137a44c..00000000000000 --- a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt +++ /dev/null @@ -1,62 +0,0 @@ -/* - * - * 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 OvenOperationalStateClusterOperationalErrorEvent( - val errorState: - matter.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterOperationalErrorEvent {\n") - append("\terrorState : $errorState\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - errorState.toTlv(ContextSpecificTag(TAG_ERROR_STATE), this) - endStructure() - } - } - - companion object { - private const val TAG_ERROR_STATE = 0 - - fun fromTlv( - tlvTag: Tag, - tlvReader: TlvReader - ): OvenOperationalStateClusterOperationalErrorEvent { - tlvReader.enterStructure(tlvTag) - val errorState = - matter.devicecontroller.cluster.structs.OvenOperationalStateClusterErrorStateStruct.fromTlv( - ContextSpecificTag(TAG_ERROR_STATE), - tlvReader - ) - - tlvReader.exitContainer() - - return OvenOperationalStateClusterOperationalErrorEvent(errorState) - } - } -} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt deleted file mode 100644 index 9c46796c30aab6..00000000000000 --- a/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt +++ /dev/null @@ -1,85 +0,0 @@ -/* - * - * 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.structs - -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 OvenOperationalStateClusterErrorStateStruct( - val errorStateID: UInt, - val errorStateLabel: Optional, - val errorStateDetails: Optional -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterErrorStateStruct {\n") - append("\terrorStateID : $errorStateID\n") - append("\terrorStateLabel : $errorStateLabel\n") - append("\terrorStateDetails : $errorStateDetails\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - put(ContextSpecificTag(TAG_ERROR_STATE_I_D), errorStateID) - if (errorStateLabel.isPresent) { - val opterrorStateLabel = errorStateLabel.get() - put(ContextSpecificTag(TAG_ERROR_STATE_LABEL), opterrorStateLabel) - } - if (errorStateDetails.isPresent) { - val opterrorStateDetails = errorStateDetails.get() - put(ContextSpecificTag(TAG_ERROR_STATE_DETAILS), opterrorStateDetails) - } - endStructure() - } - } - - companion object { - private const val TAG_ERROR_STATE_I_D = 0 - private const val TAG_ERROR_STATE_LABEL = 1 - private const val TAG_ERROR_STATE_DETAILS = 2 - - fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): OvenOperationalStateClusterErrorStateStruct { - tlvReader.enterStructure(tlvTag) - val errorStateID = tlvReader.getUInt(ContextSpecificTag(TAG_ERROR_STATE_I_D)) - val errorStateLabel = - if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) { - Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_LABEL))) - } else { - Optional.empty() - } - val errorStateDetails = - if (tlvReader.isNextTag(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) { - Optional.of(tlvReader.getString(ContextSpecificTag(TAG_ERROR_STATE_DETAILS))) - } else { - Optional.empty() - } - - tlvReader.exitContainer() - - return OvenOperationalStateClusterErrorStateStruct( - errorStateID, - errorStateLabel, - errorStateDetails - ) - } - } -} diff --git a/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt b/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt deleted file mode 100644 index 99fe7d6119c6f6..00000000000000 --- a/src/controller/java/generated/java/matter/controller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt +++ /dev/null @@ -1,74 +0,0 @@ -/* - * - * 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.structs - -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 OvenOperationalStateClusterOperationalStateStruct( - val operationalStateID: UInt, - val operationalStateLabel: Optional -) { - override fun toString(): String = buildString { - append("OvenOperationalStateClusterOperationalStateStruct {\n") - append("\toperationalStateID : $operationalStateID\n") - append("\toperationalStateLabel : $operationalStateLabel\n") - append("}\n") - } - - fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { - tlvWriter.apply { - startStructure(tlvTag) - put(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D), operationalStateID) - if (operationalStateLabel.isPresent) { - val optoperationalStateLabel = operationalStateLabel.get() - put(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL), optoperationalStateLabel) - } - endStructure() - } - } - - companion object { - private const val TAG_OPERATIONAL_STATE_I_D = 0 - private const val TAG_OPERATIONAL_STATE_LABEL = 1 - - fun fromTlv( - tlvTag: Tag, - tlvReader: TlvReader - ): OvenOperationalStateClusterOperationalStateStruct { - tlvReader.enterStructure(tlvTag) - val operationalStateID = tlvReader.getUInt(ContextSpecificTag(TAG_OPERATIONAL_STATE_I_D)) - val operationalStateLabel = - if (tlvReader.isNextTag(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) { - Optional.of(tlvReader.getString(ContextSpecificTag(TAG_OPERATIONAL_STATE_LABEL))) - } else { - Optional.empty() - } - - tlvReader.exitContainer() - - return OvenOperationalStateClusterOperationalStateStruct( - operationalStateID, - operationalStateLabel - ) - } - } -} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt deleted file mode 100644 index d05e2591fb6ff2..00000000000000 --- a/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt +++ /dev/null @@ -1,211 +0,0 @@ -/* - * - * 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 OvenOperationalStateCluster( - private val controller: MatterController, - private val endpointId: UShort -) { - class OperationalCommandResponse( - val commandResponseState: OvenOperationalStateClusterErrorStateStruct - ) - - class PhaseListAttribute(val value: List?) - - class CurrentPhaseAttribute(val value: UByte?) - - class CountdownTimeAttribute(val value: UInt?) - - class OperationalStateListAttribute( - val value: List - ) - - class OperationalErrorAttribute(val value: OvenOperationalStateClusterErrorStateStruct) - - class GeneratedCommandListAttribute(val value: List) - - class AcceptedCommandListAttribute(val value: List) - - class EventListAttribute(val value: List) - - class AttributeListAttribute(val value: List) - - suspend fun pause(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { - val commandId = 0L - - if (timedInvokeTimeoutMs != null) { - // Do the action with timedInvokeTimeoutMs - } else { - // Do the action without timedInvokeTimeoutMs - } - } - - suspend fun stop(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { - val commandId = 1L - - if (timedInvokeTimeoutMs != null) { - // Do the action with timedInvokeTimeoutMs - } else { - // Do the action without timedInvokeTimeoutMs - } - } - - suspend fun start(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { - val commandId = 2L - - if (timedInvokeTimeoutMs != null) { - // Do the action with timedInvokeTimeoutMs - } else { - // Do the action without timedInvokeTimeoutMs - } - } - - suspend fun resume(timedInvokeTimeoutMs: Int? = null): OperationalCommandResponse { - val commandId = 3L - - if (timedInvokeTimeoutMs != null) { - // Do the action with timedInvokeTimeoutMs - } else { - // Do the action without timedInvokeTimeoutMs - } - } - - suspend fun readPhaseListAttribute(): PhaseListAttribute { - // Implementation needs to be added here - } - - suspend fun subscribePhaseListAttribute(minInterval: Int, maxInterval: Int): PhaseListAttribute { - // Implementation needs to be added here - } - - suspend fun readCurrentPhaseAttribute(): CurrentPhaseAttribute { - // Implementation needs to be added here - } - - suspend fun subscribeCurrentPhaseAttribute( - minInterval: Int, - maxInterval: Int - ): CurrentPhaseAttribute { - // Implementation needs to be added here - } - - suspend fun readCountdownTimeAttribute(): CountdownTimeAttribute { - // Implementation needs to be added here - } - - suspend fun subscribeCountdownTimeAttribute( - minInterval: Int, - maxInterval: Int - ): CountdownTimeAttribute { - // Implementation needs to be added here - } - - suspend fun readOperationalStateListAttribute(): OperationalStateListAttribute { - // Implementation needs to be added here - } - - suspend fun subscribeOperationalStateListAttribute( - minInterval: Int, - maxInterval: Int - ): OperationalStateListAttribute { - // Implementation needs to be added here - } - - suspend fun readOperationalStateAttribute(): UByte { - // Implementation needs to be added here - } - - suspend fun subscribeOperationalStateAttribute(minInterval: Int, maxInterval: Int): UByte { - // Implementation needs to be added here - } - - suspend fun readOperationalErrorAttribute(): OperationalErrorAttribute { - // Implementation needs to be added here - } - - suspend fun subscribeOperationalErrorAttribute( - minInterval: Int, - maxInterval: Int - ): OperationalErrorAttribute { - // 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 = 72u - } -} diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni deleted file mode 100644 index 58232c1d089fa1..00000000000000 --- a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni +++ /dev/null @@ -1,252 +0,0 @@ -import("//build_overrides/build.gni") -import("//build_overrides/chip.gni") - -matter_structs_sources = [ - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AccessControlClusterAccessControlEntryStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AccessControlClusterAccessControlExtensionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AccessControlClusterAccessControlTargetStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ActionsClusterActionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ActionsClusterEndpointListStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ActivatedCarbonFilterMonitoringClusterReplacementProductStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ApplicationBasicClusterApplicationStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ApplicationLauncherClusterApplicationEPStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ApplicationLauncherClusterApplicationStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/AudioOutputClusterOutputInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BasicInformationClusterCapabilityMinimaStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BasicInformationClusterProductAppearanceStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BindingClusterTargetStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/BridgedDeviceBasicInformationClusterProductAppearanceStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ChannelClusterChannelInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ChannelClusterLineupInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterAdditionalInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterBrandingInformationStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterContentSearchStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterDimensionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterParameterStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ContentLauncherClusterStyleInformationStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DescriptorClusterDeviceTypeStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DescriptorClusterSemanticTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DishwasherModeClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DishwasherModeClusterModeTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DoorLockClusterCredentialStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/FixedLabelClusterLabelStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GeneralCommissioningClusterBasicCommissioningInfo.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GeneralDiagnosticsClusterNetworkInterface.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GroupKeyManagementClusterGroupInfoMapStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GroupKeyManagementClusterGroupKeyMapStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GroupKeyManagementClusterGroupKeySetStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/HepaFilterMonitoringClusterReplacementProductStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/IcdManagementClusterMonitoringRegistrationStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/LaundryWasherModeClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/LaundryWasherModeClusterModeTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MediaInputClusterInputInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MediaPlaybackClusterPlaybackPositionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MicrowaveOvenModeClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/MicrowaveOvenModeClusterModeTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ModeSelectClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ModeSelectClusterSemanticTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/NetworkCommissioningClusterNetworkInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/NetworkCommissioningClusterThreadInterfaceScanResultStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/NetworkCommissioningClusterWiFiInterfaceScanResultStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalCredentialsClusterFabricDescriptorStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalCredentialsClusterNOCStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalStateClusterErrorStateStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OperationalStateClusterOperationalStateStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OtaSoftwareUpdateRequestorClusterProviderLocation.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OvenOperationalStateClusterErrorStateStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/OvenOperationalStateClusterOperationalStateStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/PowerSourceClusterBatChargeFaultChangeType.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/PowerSourceClusterBatFaultChangeType.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/PowerSourceClusterWiredFaultChangeType.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcCleanModeClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcCleanModeClusterModeTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcOperationalStateClusterErrorStateStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcOperationalStateClusterOperationalStateStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcRunModeClusterModeOptionStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/RvcRunModeClusterModeTagStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ScenesClusterAttributeValuePair.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ScenesClusterExtensionFieldSet.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/SoftwareDiagnosticsClusterThreadMetricsStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TargetNavigatorClusterTargetInfoStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThermostatClusterThermostatScheduleTransition.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterNeighborTableStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterOperationalDatasetComponents.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterRouteTableStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/ThreadNetworkDiagnosticsClusterSecurityPolicy.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterDSTOffsetStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterTimeZoneStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/TimeSynchronizationClusterTrustedTimeSourceStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterDoubleNestedStructList.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterNestedStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterNestedStructList.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterNullablesAndOptionalsStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterSimpleStruct.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterTestFabricScoped.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UnitTestingClusterTestListStructOctet.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/UserLabelClusterLabelStruct.kt", -] - -matter_eventstructs_sources = [ - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/AccessControlClusterAccessControlEntryChangedEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/AccessControlClusterAccessControlExtensionChangedEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ActionsClusterActionFailedEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ActionsClusterStateChangedEvent.kt", - "${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/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", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DishwasherAlarmClusterNotifyEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterDoorLockAlarmEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterDoorStateChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationErrorEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockUserChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterBootReasonEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterHardwareFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterNetworkFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterRadioFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OperationalStateClusterOperationalErrorEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OperationalStateClusterOperationCompletionEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OtaSoftwareUpdateRequestorClusterDownloadErrorEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OtaSoftwareUpdateRequestorClusterStateTransitionEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OtaSoftwareUpdateRequestorClusterVersionAppliedEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationalErrorEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/OvenOperationalStateClusterOperationCompletionEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/PowerSourceClusterBatChargeFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/PowerSourceClusterBatFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/PowerSourceClusterWiredFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/RefrigeratorAlarmClusterNotifyEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/RvcOperationalStateClusterOperationalErrorEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/RvcOperationalStateClusterOperationCompletionEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterCOAlarmEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectCOAlarmEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterInterconnectSmokeAlarmEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterLowBatteryEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SmokeCoAlarmClusterSmokeAlarmEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SoftwareDiagnosticsClusterSoftwareFaultEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterInitialPressEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterLongPressEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterLongReleaseEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterMultiPressCompleteEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterMultiPressOngoingEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterShortReleaseEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/SwitchClusterSwitchLatchedEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterConnectionStatusEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/TimeSynchronizationClusterDSTStatusEvent.kt", - "${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/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", -] - -matter_clusters_sources = [ - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AccessControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AccountLoginCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ActionsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ActivatedCarbonFilterMonitoringCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AdministratorCommissioningCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AirQualityCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ApplicationBasicCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ApplicationLauncherCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/AudioOutputCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BallastConfigurationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/BarrierControlCluster.kt", - "${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/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", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/CarbonMonoxideConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ChannelCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ColorControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ContentLauncherCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DescriptorCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DiagnosticLogsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DishwasherAlarmCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DishwasherModeCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DoorLockCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ElectricalMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EthernetNetworkDiagnosticsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FanControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FaultInjectionCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FixedLabelCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FlowMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FormaldehydeConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GeneralCommissioningCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GeneralDiagnosticsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GroupKeyManagementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/GroupsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/HepaFilterMonitoringCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/IcdManagementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/IdentifyCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/IlluminanceMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/KeypadInputCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LaundryWasherControlsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LaundryWasherModeCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LevelControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LocalizationConfigurationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/LowPowerCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MediaInputCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MediaPlaybackCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MicrowaveOvenControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/MicrowaveOvenModeCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ModeSelectCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/NetworkCommissioningCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/NitrogenDioxideConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OccupancySensingCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OnOffCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OnOffSwitchConfigurationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OperationalCredentialsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OperationalStateCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OtaSoftwareUpdateProviderCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OtaSoftwareUpdateRequestorCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OvenOperationalStateCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/OzoneConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/Pm10ConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/Pm1ConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/Pm25ConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PowerSourceCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PowerSourceConfigurationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PressureMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ProxyConfigurationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ProxyDiscoveryCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ProxyValidCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PulseWidthModulationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/PumpConfigurationAndControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RadonConcentrationMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RefrigeratorAlarmCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RefrigeratorAndTemperatureControlledCabinetModeCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RelativeHumidityMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RvcCleanModeCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RvcOperationalStateCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/RvcRunModeCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SampleMeiCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ScenesCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SmokeCoAlarmCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SoftwareDiagnosticsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/SwitchCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TargetNavigatorCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TemperatureControlCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TemperatureMeasurementCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ThermostatCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ThermostatUserInterfaceConfigurationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ThreadNetworkDiagnosticsCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TimeFormatLocalizationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TimeSynchronizationCluster.kt", - "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/TotalVolatileOrganicCompoundsConcentrationMeasurementCluster.kt", - "${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/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", -] \ No newline at end of file diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java deleted file mode 100644 index 5f4c1939a70cb6..00000000000000 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ /dev/null @@ -1,40491 +0,0 @@ -/* - * - * 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 BooleanStateConfigurationCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 0x00000080L; - - public BooleanStateConfigurationCluster(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); - } -} From 94981e4c0ff02f8ef75c7eba435b79f66bb625f7 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Thu, 21 Dec 2023 10:58:43 -0600 Subject: [PATCH 07/26] cleanup --- .../include/oven-operational-state-delegate.h | 27 +------------------ .../src/oven-operational-state-delegate.cpp | 10 ------- 2 files changed, 1 insertion(+), 36 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index 70e825a7f64905..349dd0a36529ff 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -27,10 +27,6 @@ namespace chip { namespace app { namespace Clusters { -// class RvcDevice; - -// typedef void (RvcDevice::*HandleOpStateCommand)(Clusters::OperationalState::GenericOperationalError & err); - namespace OvenCavityOperationalState { // This is an application level delegate to handle operational state commands according to the specific business logic. @@ -42,10 +38,6 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kRunning)), OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kPaused)), OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kError)), - // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kPreheating)), - // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kPreheated)), - // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kCoolingDown)), - // OperationalState::GenericOperationalState(to_underlying(Clusters::OvenCavityOperationalState::OperationalStateEnum::kSelfCleaning)) }; const Clusters::OperationalState::GenericOperationalPhase mOperationalPhaseList[1] = { @@ -53,14 +45,9 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate OperationalState::GenericOperationalPhase(DataModel::Nullable()), }; - // RvcDevice * mPauseRvcDeviceInstance; - // HandleOpStateCommand mPauseCallback; - // RvcDevice * mResumeRvcDeviceInstance; - // HandleOpStateCommand mResumeCallback; - public: /** - * Get the countdown time. This attribute is not supported in our example RVC app. + * Get the countdown time. This attribute is not supported in our example app. * @return Null. */ DataModel::Nullable GetCountdownTime() override { return {}; }; @@ -119,18 +106,6 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate void HandleStopStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ // This command in not supported. }; - - // void SetPauseCallback(HandleOpStateCommand aCallback, RvcDevice * aInstance) - // { - // mPauseCallback = aCallback; - // mPauseRvcDeviceInstance = aInstance; - // }; - - // void SetResumeCallback(HandleOpStateCommand aCallback, RvcDevice * aInstance) - // { - // mResumeCallback = aCallback; - // mResumeRvcDeviceInstance = aInstance; - // }; }; void Shutdown(); diff --git a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp index 5ca088e12fb4ad..ea1b8debc9e288 100644 --- a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp @@ -77,13 +77,3 @@ OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, operationalPhase = mOperationalPhaseList[index]; return CHIP_NO_ERROR; } - -// void RvcOperationalStateDelegate::HandlePauseStateCallback(OperationalState::GenericOperationalError & err) -// { -// (mPauseRvcDeviceInstance->*mPauseCallback)(err); -// } - -// void RvcOperationalStateDelegate::HandleResumeStateCallback(OperationalState::GenericOperationalError & err) -// { -// (mResumeRvcDeviceInstance->*mResumeCallback)(err); -// } From 9023f72c3f878ea4344670d2eaa0f70865ad1529 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Thu, 21 Dec 2023 11:31:27 -0600 Subject: [PATCH 08/26] cleanup: removing unneeded files. --- .../operational-state-oven-cluster-objects.h | 271 ------------ .../operational-state-oven-server.cpp | 411 ------------------ .../operational-state-oven-server.h | 280 ------------ 3 files changed, 962 deletions(-) delete mode 100644 src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h delete mode 100644 src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp delete mode 100644 src/app/clusters/operational-state-oven-server/operational-state-oven-server.h diff --git a/src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h b/src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h deleted file mode 100644 index 1910e00d20effb..00000000000000 --- a/src/app/clusters/operational-state-oven-server/operational-state-oven-cluster-objects.h +++ /dev/null @@ -1,271 +0,0 @@ -/* - * - * Copyright (c) 2023 Project CHIP Authors - * All rights reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#pragma once - -#include -#include -#include - -namespace chip { -namespace app { -namespace Clusters { -namespace OperationalState { - -inline constexpr size_t kOperationalStateLabelMaxSize = 64u; -inline constexpr size_t kOperationalErrorLabelMaxSize = 64u; -inline constexpr size_t kOperationalErrorDetailsMaxSize = 64u; -inline constexpr size_t kOperationalPhaseNameMaxSize = 64u; - -/** - * A class which represents the operational state of an Operational State cluster derivation instance. - */ -struct GenericOperationalState : public app::Clusters::detail::Structs::OperationalStateStruct::Type -{ - GenericOperationalState(uint8_t state = to_underlying(OperationalStateEnum::kStopped), Optional label = NullOptional) - { - Set(state, label); - } - - GenericOperationalState(const GenericOperationalState & op) { *this = op; } - - GenericOperationalState & operator=(const GenericOperationalState & op) - { - Set(op.operationalStateID, op.operationalStateLabel); - return *this; - } - - void Set(uint8_t state, Optional label = NullOptional) - { - operationalStateID = state; - if (label.HasValue()) - { - memset(mOperationalStateLabelBuffer, 0, sizeof(mOperationalStateLabelBuffer)); - if (label.Value().size() > sizeof(mOperationalStateLabelBuffer)) - { - memcpy(mOperationalStateLabelBuffer, label.Value().data(), sizeof(mOperationalStateLabelBuffer)); - operationalStateLabel.SetValue(CharSpan(mOperationalStateLabelBuffer, sizeof(mOperationalStateLabelBuffer))); - } - else - { - memcpy(mOperationalStateLabelBuffer, label.Value().data(), label.Value().size()); - operationalStateLabel.SetValue(CharSpan(mOperationalStateLabelBuffer, label.Value().size())); - } - } - else - { - operationalStateLabel = NullOptional; - } - } - -private: - char mOperationalStateLabelBuffer[kOperationalStateLabelMaxSize]; -}; - -/** - * A class which represents the operational error of an Operational State cluster derivation instance. - */ -struct GenericOperationalError : public app::Clusters::detail::Structs::ErrorStateStruct::Type -{ - GenericOperationalError(uint8_t state, Optional label = NullOptional, - Optional details = NullOptional) - { - Set(state, label, details); - } - - GenericOperationalError(const GenericOperationalError & error) { *this = error; } - - GenericOperationalError & operator=(const GenericOperationalError & error) - { - Set(error.errorStateID, error.errorStateLabel, error.errorStateDetails); - return *this; - } - - void Set(uint8_t state, Optional label = NullOptional, Optional details = NullOptional) - { - errorStateID = state; - if (label.HasValue()) - { - memset(mErrorStateLabelBuffer, 0, sizeof(mErrorStateLabelBuffer)); - if (label.Value().size() > sizeof(mErrorStateLabelBuffer)) - { - memcpy(mErrorStateLabelBuffer, label.Value().data(), sizeof(mErrorStateLabelBuffer)); - errorStateLabel.SetValue(CharSpan(mErrorStateLabelBuffer, sizeof(mErrorStateLabelBuffer))); - } - else - { - memcpy(mErrorStateLabelBuffer, label.Value().data(), label.Value().size()); - errorStateLabel.SetValue(CharSpan(mErrorStateLabelBuffer, label.Value().size())); - } - } - else - { - errorStateLabel = NullOptional; - } - - if (details.HasValue()) - { - memset(mErrorStateDetailsBuffer, 0, sizeof(mErrorStateDetailsBuffer)); - if (details.Value().size() > sizeof(mErrorStateDetailsBuffer)) - { - memcpy(mErrorStateDetailsBuffer, details.Value().data(), sizeof(mErrorStateDetailsBuffer)); - errorStateDetails.SetValue(CharSpan(mErrorStateDetailsBuffer, sizeof(mErrorStateDetailsBuffer))); - } - else - { - memcpy(mErrorStateDetailsBuffer, details.Value().data(), details.Value().size()); - errorStateDetails.SetValue(CharSpan(mErrorStateDetailsBuffer, details.Value().size())); - } - } - else - { - errorStateDetails = NullOptional; - } - } - - bool IsEqual(const Structs::ErrorStateStruct::Type & rhs) const - { - if (errorStateID != rhs.errorStateID) - { - return false; - } - if (errorStateLabel.HasValue() != rhs.errorStateLabel.HasValue() || - errorStateDetails.HasValue() != rhs.errorStateDetails.HasValue()) - { - return false; - } - if (errorStateLabel.HasValue()) - { - if (!errorStateLabel.Value().data_equal(rhs.errorStateLabel.Value())) - { - return false; - } - } - if (errorStateDetails.HasValue()) - { - if (!errorStateDetails.Value().data_equal(rhs.errorStateDetails.Value())) - { - return false; - } - } - - return true; - } - -private: - char mErrorStateLabelBuffer[kOperationalErrorLabelMaxSize]; - char mErrorStateDetailsBuffer[kOperationalErrorDetailsMaxSize]; -}; - -/** - * A class which represents the operational phase of an Operational State cluster derivation instance. - */ -struct GenericOperationalPhase -{ - GenericOperationalPhase(app::DataModel::Nullable name) { Set(name); } - - GenericOperationalPhase(const GenericOperationalPhase & ph) { *this = ph; } - - GenericOperationalPhase & operator=(const GenericOperationalPhase & ph) - { - Set(ph.mPhaseName); - return *this; - } - - bool IsMissing() const { return mPhaseName.IsNull(); } - app::DataModel::Nullable mPhaseName; - -private: - void Set(app::DataModel::Nullable name) - { - if (name.IsNull()) - { - mPhaseName.SetNull(); - } - else - { - memset(mPhaseNameBuffer, 0, sizeof(mPhaseNameBuffer)); - if (name.Value().size() > sizeof(mPhaseNameBuffer)) - { - memcpy(mPhaseNameBuffer, name.Value().data(), sizeof(mPhaseNameBuffer)); - mPhaseName = app::DataModel::Nullable(CharSpan(mPhaseNameBuffer, sizeof(mPhaseNameBuffer))); - } - else - { - memcpy(mPhaseNameBuffer, name.Value().data(), name.Value().size()); - mPhaseName = app::DataModel::Nullable(CharSpan(mPhaseNameBuffer, name.Value().size())); - } - } - } - - char mPhaseNameBuffer[kOperationalPhaseNameMaxSize]; -}; - -/** - * A class which represents the operational error event of an Operational State cluster derivation instance. - */ -class GenericErrorEvent : private app::Clusters::OperationalState::Events::OperationalError::Type -{ - using super = app::Clusters::OperationalState::Events::OperationalError::Type; - -public: - GenericErrorEvent(ClusterId aClusterId, const Structs::ErrorStateStruct::Type & aError) : mClusterId(aClusterId) - { - errorState = aError; - } - using super::GetEventId; - using super::GetPriorityLevel; - ClusterId GetClusterId() const { return mClusterId; } - using super::Encode; - using super::kIsFabricScoped; - -private: - ClusterId mClusterId; -}; - -/** - * A class which represents the operational completion event of an Operational State cluster derivation instance. - */ -class GenericOperationCompletionEvent : private app::Clusters::OperationalState::Events::OperationCompletion::Type -{ - using super = app::Clusters::OperationalState::Events::OperationCompletion::Type; - -public: - GenericOperationCompletionEvent(ClusterId aClusterId, uint8_t aCompletionErrorCode, - const Optional> & aTotalOperationalTime = NullOptional, - const Optional> & aPausedTime = NullOptional) : - mClusterId(aClusterId) - { - completionErrorCode = aCompletionErrorCode; - totalOperationalTime = aTotalOperationalTime; - pausedTime = aPausedTime; - } - using super::GetEventId; - using super::GetPriorityLevel; - ClusterId GetClusterId() const { return mClusterId; } - using super::Encode; - using super::kIsFabricScoped; - -private: - ClusterId mClusterId; -}; - -} // namespace OperationalState -} // namespace Clusters -} // namespace app -} // namespace chip diff --git a/src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp b/src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp deleted file mode 100644 index 3c4809401b8db3..00000000000000 --- a/src/app/clusters/operational-state-oven-server/operational-state-oven-server.cpp +++ /dev/null @@ -1,411 +0,0 @@ -/* - * - * 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. - */ - -/**************************************************************************** - * @file - * @brief Implementation for the Operational State Server Cluster - ***************************************************************************/ -#include "operational-state-oven-server.h" -#include -#include -#include -#include -#include -#include - -using namespace chip; -using namespace chip::app; -using namespace chip::app::Clusters; -using namespace chip::app::Clusters::OperationalState; -using namespace chip::app::Clusters::OperationalState::Attributes; - -using Status = Protocols::InteractionModel::Status; - -Instance::Instance(Delegate * aDelegate, EndpointId aEndpointId, ClusterId aClusterId) : - CommandHandlerInterface(MakeOptional(aEndpointId), aClusterId), AttributeAccessInterface(MakeOptional(aEndpointId), aClusterId), - mDelegate(aDelegate), mEndpointId(aEndpointId), mClusterId(aClusterId) -{ - mDelegate->SetInstance(this); -} - -Instance::~Instance() -{ - InteractionModelEngine::GetInstance()->UnregisterCommandHandler(this); - unregisterAttributeAccessOverride(this); -} - -CHIP_ERROR Instance::Init() -{ - // Check if the cluster has been selected in zap - if (!emberAfContainsServer(mEndpointId, mClusterId)) - { - ChipLogError(Zcl, "Operational State: The cluster with ID %lu was not enabled in zap.", long(mClusterId)); - return CHIP_ERROR_INVALID_ARGUMENT; - } - - ReturnErrorOnFailure(InteractionModelEngine::GetInstance()->RegisterCommandHandler(this)); - - VerifyOrReturnError(registerAttributeAccessOverride(this), CHIP_ERROR_INCORRECT_STATE); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR Instance::SetCurrentPhase(const DataModel::Nullable & aPhase) -{ - if (!aPhase.IsNull()) - { - if (!IsSupportedPhase(aPhase.Value())) - { - return CHIP_ERROR_INVALID_ARGUMENT; - } - } - - DataModel::Nullable oldPhase = mCurrentPhase; - mCurrentPhase = aPhase; - if (mCurrentPhase != oldPhase) - { - MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::CurrentPhase::Id); - } - return CHIP_NO_ERROR; -} - -CHIP_ERROR Instance::SetOperationalState(uint8_t aOpState) -{ - // Error is only allowed to be set by OnOperationalErrorDetected. - if (aOpState == to_underlying(OperationalStateEnum::kError) || !IsSupportedOperationalState(aOpState)) - { - return CHIP_ERROR_INVALID_ARGUMENT; - } - - if (mOperationalError.errorStateID != to_underlying(ErrorStateEnum::kNoError)) - { - mOperationalError.Set(to_underlying(ErrorStateEnum::kNoError)); - MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalError::Id); - } - - uint8_t oldState = mOperationalState; - mOperationalState = aOpState; - if (mOperationalState != oldState) - { - MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalState::Id); - } - return CHIP_NO_ERROR; -} - -DataModel::Nullable Instance::GetCurrentPhase() const -{ - return mCurrentPhase; -} - -uint8_t Instance::GetCurrentOperationalState() const -{ - return mOperationalState; -} - -void Instance::GetCurrentOperationalError(GenericOperationalError & error) const -{ - error.Set(mOperationalError.errorStateID, mOperationalError.errorStateLabel, mOperationalError.errorStateDetails); -} - -void Instance::OnOperationalErrorDetected(const Structs::ErrorStateStruct::Type & aError) -{ - ChipLogDetail(Zcl, "OperationalStateServer: OnOperationalErrorDetected"); - // Set the OperationalState attribute to Error - if (mOperationalState != to_underlying(OperationalStateEnum::kError)) - { - mOperationalState = to_underlying(OperationalStateEnum::kError); - MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalState::Id); - } - - // Set the OperationalError attribute - if (!mOperationalError.IsEqual(aError)) - { - mOperationalError.Set(aError.errorStateID, aError.errorStateLabel, aError.errorStateDetails); - MatterReportingAttributeChangeCallback(mEndpointId, mClusterId, Attributes::OperationalError::Id); - } - - // Generate an ErrorDetected event - GenericErrorEvent event(mClusterId, aError); - EventNumber eventNumber; - CHIP_ERROR error = LogEvent(event, mEndpointId, eventNumber); - - if (error != CHIP_NO_ERROR) - { - ChipLogError(Zcl, "OperationalStateServer: Failed to record OperationalError event: %" CHIP_ERROR_FORMAT, error.Format()); - } -} - -void Instance::OnOperationCompletionDetected(uint8_t aCompletionErrorCode, - const Optional> & aTotalOperationalTime, - const Optional> & aPausedTime) const -{ - ChipLogDetail(Zcl, "OperationalStateServer: OnOperationCompletionDetected"); - - GenericOperationCompletionEvent event(mClusterId, aCompletionErrorCode, aTotalOperationalTime, aPausedTime); - EventNumber eventNumber; - CHIP_ERROR error = LogEvent(event, mEndpointId, eventNumber); - - if (error != CHIP_NO_ERROR) - { - ChipLogError(Zcl, "OperationalStateServer: Failed to record OperationCompletion event: %" CHIP_ERROR_FORMAT, - error.Format()); - } -} - -void Instance::ReportOperationalStateListChange() -{ - MatterReportingAttributeChangeCallback(ConcreteAttributePath(mEndpointId, mClusterId, Attributes::OperationalStateList::Id)); -} - -void Instance::ReportPhaseListChange() -{ - MatterReportingAttributeChangeCallback(ConcreteAttributePath(mEndpointId, mClusterId, Attributes::PhaseList::Id)); -} - -bool Instance::IsSupportedPhase(uint8_t aPhase) -{ - GenericOperationalPhase phase = GenericOperationalPhase(DataModel::Nullable()); - if (mDelegate->GetOperationalPhaseAtIndex(aPhase, phase) != CHIP_ERROR_NOT_FOUND) - { - return true; - } - return false; -} - -bool Instance::IsSupportedOperationalState(uint8_t aState) -{ - GenericOperationalState opState; - for (uint8_t i = 0; mDelegate->GetOperationalStateAtIndex(i, opState) != CHIP_ERROR_NOT_FOUND; i++) - { - if (opState.operationalStateID == aState) - { - return true; - } - } - ChipLogDetail(Zcl, "Cannot find an operational state with value %u", aState); - return false; -} - -// private - -template -void Instance::HandleCommand(HandlerContext & handlerContext, FuncT func) -{ - if (!handlerContext.mCommandHandled && (handlerContext.mRequestPath.mCommandId == RequestT::GetCommandId())) - { - RequestT requestPayload; - - // If the command matches what the caller is looking for, let's mark this as being handled - // even if errors happen after this. This ensures that we don't execute any fall-back strategies - // to handle this command since at this point, the caller is taking responsibility for handling - // the command in its entirety, warts and all. - // - handlerContext.SetCommandHandled(); - - if (DataModel::Decode(handlerContext.mPayload, requestPayload) != CHIP_NO_ERROR) - { - handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, - Protocols::InteractionModel::Status::InvalidCommand); - return; - } - - func(handlerContext, requestPayload); - } -} - -// This function is called by the interaction model engine when a command destined for this instance is received. -void Instance::InvokeCommand(HandlerContext & handlerContext) -{ - ChipLogDetail(Zcl, "OperationalState: InvokeCommand"); - switch (handlerContext.mRequestPath.mCommandId) - { - case Commands::Pause::Id: - ChipLogDetail(Zcl, "OperationalState: Entering handling Pause state"); - - HandleCommand( - handlerContext, [this](HandlerContext & ctx, const auto & req) { HandlePauseState(ctx, req); }); - break; - - case Commands::Resume::Id: - ChipLogDetail(Zcl, "OperationalState: Entering handling Resume state"); - - HandleCommand( - handlerContext, [this](HandlerContext & ctx, const auto & req) { HandleResumeState(ctx, req); }); - break; - - case Commands::Start::Id: - ChipLogDetail(Zcl, "OperationalState: Entering handling Start state"); - - HandleCommand( - handlerContext, [this](HandlerContext & ctx, const auto & req) { HandleStartState(ctx, req); }); - break; - - case Commands::Stop::Id: - ChipLogDetail(Zcl, "OperationalState: Entering handling Stop state"); - - HandleCommand(handlerContext, - [this](HandlerContext & ctx, const auto & req) { HandleStopState(ctx, req); }); - break; - } -} - -CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) -{ - ChipLogError(Zcl, "OperationalState: Reading"); - switch (aPath.mAttributeId) - { - case OperationalState::Attributes::OperationalStateList::Id: { - return aEncoder.EncodeList([delegate = mDelegate](const auto & encoder) -> CHIP_ERROR { - GenericOperationalState opState; - size_t index = 0; - CHIP_ERROR err = CHIP_NO_ERROR; - while ((err = delegate->GetOperationalStateAtIndex(index, opState)) == CHIP_NO_ERROR) - { - ReturnErrorOnFailure(encoder.Encode(opState)); - index++; - } - if (err == CHIP_ERROR_NOT_FOUND) - { - return CHIP_NO_ERROR; - } - return err; - }); - } - break; - - case OperationalState::Attributes::OperationalState::Id: { - ChipLogError(Zcl, "OperationalState: H1"); - ReturnErrorOnFailure(aEncoder.Encode(GetCurrentOperationalState())); - } - break; - - case OperationalState::Attributes::OperationalError::Id: { - ReturnErrorOnFailure(aEncoder.Encode(mOperationalError)); - } - break; - - case OperationalState::Attributes::PhaseList::Id: { - GenericOperationalPhase phase = GenericOperationalPhase(DataModel::Nullable()); - size_t index = 0; - - if (mDelegate->GetOperationalPhaseAtIndex(index, phase) == CHIP_ERROR_NOT_FOUND || phase.IsMissing()) - { - return aEncoder.EncodeNull(); - } - return aEncoder.EncodeList([&](const auto & encoder) -> CHIP_ERROR { - while (this->mDelegate->GetOperationalPhaseAtIndex(index, phase) != CHIP_ERROR_NOT_FOUND) - { - ReturnErrorOnFailure(encoder.Encode(phase.mPhaseName)); - index++; - } - return CHIP_NO_ERROR; - }); - } - break; - - case OperationalState::Attributes::CurrentPhase::Id: { - ReturnErrorOnFailure(aEncoder.Encode(GetCurrentPhase())); - } - break; - - case OperationalState::Attributes::CountdownTime::Id: { - ReturnErrorOnFailure(aEncoder.Encode(mDelegate->GetCountdownTime())); - } - break; - } - return CHIP_NO_ERROR; -} - -void Instance::HandlePauseState(HandlerContext & ctx, const Commands::Pause::DecodableType & req) -{ - ChipLogDetail(Zcl, "OperationalState: HandlePauseState"); - - GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); - uint8_t opState = GetCurrentOperationalState(); - - if (opState != to_underlying(OperationalStateEnum::kPaused) && opState != to_underlying(OperationalStateEnum::kRunning)) - { - err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); - } - else if (opState == to_underlying(OperationalStateEnum::kRunning)) - { - mDelegate->HandlePauseStateCallback(err); - } - - Commands::OperationalCommandResponse::Type response; - response.commandResponseState = err; - - ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); -} - -void Instance::HandleStopState(HandlerContext & ctx, const Commands::Stop::DecodableType & req) -{ - ChipLogDetail(Zcl, "OperationalState: HandleStopState"); - - GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); - uint8_t opState = GetCurrentOperationalState(); - - if (opState != to_underlying(OperationalStateEnum::kStopped)) - { - mDelegate->HandleStopStateCallback(err); - } - - Commands::OperationalCommandResponse::Type response; - response.commandResponseState = err; - - ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); -} - -void Instance::HandleStartState(HandlerContext & ctx, const Commands::Start::DecodableType & req) -{ - ChipLogDetail(Zcl, "OperationalState: HandleStartState"); - - GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); - uint8_t opState = GetCurrentOperationalState(); - - if (opState != to_underlying(OperationalStateEnum::kRunning)) - { - mDelegate->HandleStartStateCallback(err); - } - - Commands::OperationalCommandResponse::Type response; - response.commandResponseState = err; - - ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); -} - -void Instance::HandleResumeState(HandlerContext & ctx, const Commands::Resume::DecodableType & req) -{ - ChipLogDetail(Zcl, "OperationalState: HandleResumeState"); - - GenericOperationalError err(to_underlying(ErrorStateEnum::kNoError)); - uint8_t opState = GetCurrentOperationalState(); - - if (opState != to_underlying(OperationalStateEnum::kPaused) && opState != to_underlying(OperationalStateEnum::kRunning)) - { - err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); - } - else if (opState == to_underlying(OperationalStateEnum::kPaused)) - { - mDelegate->HandleResumeStateCallback(err); - } - - Commands::OperationalCommandResponse::Type response; - response.commandResponseState = err; - - ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response); -} diff --git a/src/app/clusters/operational-state-oven-server/operational-state-oven-server.h b/src/app/clusters/operational-state-oven-server/operational-state-oven-server.h deleted file mode 100644 index 23ebba36817d22..00000000000000 --- a/src/app/clusters/operational-state-oven-server/operational-state-oven-server.h +++ /dev/null @@ -1,280 +0,0 @@ -/* - * - * Copyright (c) 2023 Project CHIP Authors - * All rights reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#pragma once - -#include "operational-state-oven-cluster-objects.h" -#include -#include -#include -#include - -namespace chip { -namespace app { -namespace Clusters { -namespace OperationalState { - -class Uncopyable -{ -protected: - Uncopyable() {} - ~Uncopyable() = default; - -private: - Uncopyable(const Uncopyable &) = delete; - Uncopyable & operator=(const Uncopyable &) = delete; -}; - -class Delegate; - -/** - * Instance is a class that represents an instance of a derivation of the operational state cluster. - * It implements CommandHandlerInterface so it can generically handle commands for any derivation cluster id. - */ -class Instance : public CommandHandlerInterface, public AttributeAccessInterface, public Uncopyable -{ -public: - /** - * Creates an operational state cluster instance. The Init() function needs to be called for this instance - * to be registered and called by the interaction model at the appropriate times. - * It is possible to set the CurrentPhase and OperationalState via the Set... methods before calling Init(). - * @param aDelegate A pointer to the delegate to be used by this server. - * Note: the caller must ensure that the delegate lives throughout the instance's lifetime. - * @param aEndpointId The endpoint on which this cluster exists. This must match the zap configuration. - * @param aClusterId The ID of the operational state derived cluster to be instantiated. - */ - Instance(Delegate * aDelegate, EndpointId aEndpointId, ClusterId aClusterId); - - ~Instance() override; - - /** - * Initialise the operational state server instance. - * This function must be called after defining an Instance class object. - * @return Returns an error if the given endpoint and cluster ID have not been enabled in zap or if the - * CommandHandler or AttributeHandler registration fails, else returns CHIP_NO_ERROR. - */ - CHIP_ERROR Init(); - - // Attribute setters - /** - * Set operational phase. - * @param aPhase The operational phase that should now be the current one. - * @return CHIP_ERROR_INVALID_ARGUMENT if aPhase is an invalid value. CHIP_NO_ERROR if set was successful. - */ - CHIP_ERROR SetCurrentPhase(const app::DataModel::Nullable & aPhase); - - /** - * Set current operational state to aOpState and the operational error to kNoError. - * NOTE: This method cannot be used to set the error state. The error state must be set via the - * OnOperationalErrorDetected method. - * @param aOpState The operational state that should now be the current one. - * @return CHIP_ERROR_INVALID_ARGUMENT if aOpState is an invalid value. CHIP_NO_ERROR if set was successful. - */ - CHIP_ERROR SetOperationalState(uint8_t aOpState); - - // Attribute getters - /** - * Get current phase. - * @return The current phase. - */ - app::DataModel::Nullable GetCurrentPhase() const; - - /** - * Get the current operational state. - * @return The current operational state value. - */ - uint8_t GetCurrentOperationalState() const; - - /** - * Get current operational error. - * @param error The GenericOperationalError to fill with the current operational error value - */ - void GetCurrentOperationalError(GenericOperationalError & error) const; - - // Event triggers - /** - * @brief Called when the Node detects a OperationalError has been raised. - * Note: This function also sets the OperationalState attribute to Error. - * @param aError OperationalError which detects - */ - void OnOperationalErrorDetected(const Structs::ErrorStateStruct::Type & aError); - - /** - * @brief Called when the Node detects a OperationCompletion has been raised. - * @param aCompletionErrorCode CompletionErrorCode - * @param aTotalOperationalTime TotalOperationalTime - * @param aPausedTime PausedTime - */ - void OnOperationCompletionDetected(uint8_t aCompletionErrorCode, - const Optional> & aTotalOperationalTime = NullOptional, - const Optional> & aPausedTime = NullOptional) const; - - // List change reporting - /** - * Reports that the contents of the operational state list has changed. - * The device SHALL call this method whenever it changes the operational state list. - */ - void ReportOperationalStateListChange(); - - /** - * Reports that the contents of the phase list has changed. - * The device SHALL call this method whenever it changes the phase list. - */ - void ReportPhaseListChange(); - - /** - * This function returns true if the phase value given exists in the PhaseList attribute, otherwise it returns false. - */ - bool IsSupportedPhase(uint8_t aPhase); - - /** - * This function returns true if the operational state value given exists in the OperationalStateList attribute, - * otherwise it returns false. - */ - bool IsSupportedOperationalState(uint8_t aState); - -private: - Delegate * mDelegate; - - EndpointId mEndpointId; - ClusterId mClusterId; - - // Attribute Data Store - app::DataModel::Nullable mCurrentPhase; - uint8_t mOperationalState = 0; // assume 0 for now. - GenericOperationalError mOperationalError = to_underlying(ErrorStateEnum::kNoError); - - // Inherited from CommandHandlerInterface - template - void HandleCommand(HandlerContext & handlerContext, FuncT func); - - // Inherited from CommandHandlerInterface - void InvokeCommand(HandlerContext & ctx) override; - - /** - * IM-level implementation of read - * @return appropriately mapped CHIP_ERROR if applicable (may return CHIP_IM_GLOBAL_STATUS errors) - */ - CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override; - - /** - * Handle Command: Pause. - */ - void HandlePauseState(HandlerContext & ctx, const Commands::Pause::DecodableType & req); - - /** - * Handle Command: Stop. - */ - void HandleStopState(HandlerContext & ctx, const Commands::Stop::DecodableType & req); - - /** - * Handle Command: Start. - */ - void HandleStartState(HandlerContext & ctx, const Commands::Start::DecodableType & req); - - /** - * Handle Command: Resume. - */ - void HandleResumeState(HandlerContext & ctx, const Commands::Resume::DecodableType & req); -}; - -/** - * A delegate to handle application logic of the Operational State aliased Cluster. - * The delegate API assumes there will be separate delegate objects for each cluster instance. - * (i.e. each separate operational state cluster derivation, on each separate endpoint), - * since the delegate methods are not handed the cluster id or endpoint. - */ -class Delegate -{ -public: - Delegate() = default; - - virtual ~Delegate() = default; - - /** - * Get the countdown time. - * NOTE: Changes to this attribute should not be reported. - * From the spec: Changes to this value SHALL NOT be reported in a subscription. - * @return The current countdown time. - */ - virtual app::DataModel::Nullable GetCountdownTime() = 0; - - /** - * Fills in the provided GenericOperationalState with the state at index `index` if there is one, - * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of states. - * Note: This is used by the SDK to populate the operational state list attribute. If the contents of this list changes, - * the device SHALL call the Instance's ReportOperationalStateListChange method to report that this attribute has changed. - * @param index The index of the state, with 0 representing the first state. - * @param operationalState The GenericOperationalState is filled. - */ - virtual CHIP_ERROR GetOperationalStateAtIndex(size_t index, GenericOperationalState & operationalState) = 0; - - /** - * Fills in the provided GenericOperationalPhase with the phase at index `index` if there is one, - * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of phases. - * Note: This is used by the SDK to populate the phase list attribute. If the contents of this list changes, the - * device SHALL call the Instance's ReportPhaseListChange method to report that this attribute has changed. - * @param index The index of the phase, with 0 representing the first phase. - * @param operationalPhase The GenericOperationalPhase is filled. - */ - virtual CHIP_ERROR GetOperationalPhaseAtIndex(size_t index, GenericOperationalPhase & operationalPhase) = 0; - - // command callback - /** - * Handle Command Callback in application: Pause - * @param[out] err operational error after callback. - */ - virtual void HandlePauseStateCallback(GenericOperationalError & err) = 0; - - /** - * Handle Command Callback in application: Resume - * @param[out] err operational error after callback. - */ - virtual void HandleResumeStateCallback(GenericOperationalError & err) = 0; - - /** - * Handle Command Callback in application: Start - * @param[out] err operational error after callback. - */ - virtual void HandleStartStateCallback(GenericOperationalError & err) = 0; - - /** - * Handle Command Callback in application: Stop - * @param[out] err operational error after callback. - */ - virtual void HandleStopStateCallback(GenericOperationalError & err) = 0; - -private: - friend class Instance; - - Instance * mInstance = nullptr; - - /** - * This method is used by the SDK to set the instance pointer. This is done during the instantiation of a Instance object. - * @param aInstance A pointer to the Instance object related to this delegate object. - */ - void SetInstance(Instance * aInstance) { mInstance = aInstance; } - -protected: - Instance * GetInstance() const { return mInstance; } -}; - -} // namespace OperationalState -} // namespace Clusters -} // namespace app -} // namespace chip From d743ee6e2938dc8f9930a4748a0ab73b3440aafa Mon Sep 17 00:00:00 2001 From: OmAmbalkar <36728913+OmAmbalkar@users.noreply.github.com> Date: Wed, 3 Jan 2024 11:04:45 -0600 Subject: [PATCH 09/26] Set err in commands, removed function definition for phases, returned NullNullable --- .../include/oven-operational-state-delegate.h | 6 +++++- .../src/oven-operational-state-delegate.cpp | 7 +------ 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index 349dd0a36529ff..b523477dc8ec97 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -50,7 +50,7 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate * Get the countdown time. This attribute is not supported in our example app. * @return Null. */ - DataModel::Nullable GetCountdownTime() override { return {}; }; + DataModel::Nullable GetCountdownTime() override { return DataModel::NullNullable; }; /** * Fills in the provided GenericOperationalState with the state at index `index` if there is one, @@ -81,6 +81,7 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate */ void HandlePauseStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ // This command in not supported. + err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; /** @@ -89,6 +90,7 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate */ void HandleResumeStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ // This command in not supported. + err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; /** @@ -97,6 +99,7 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate */ void HandleStartStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ // This command in not supported. + err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; /** @@ -105,6 +108,7 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate */ void HandleStopStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ // This command in not supported. + err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; }; diff --git a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp index ea1b8debc9e288..9cfd86db206895 100644 --- a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp @@ -70,10 +70,5 @@ CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, OperationalState::GenericOperationalPhase & operationalPhase) { - if (index >= ArraySize(mOperationalPhaseList)) - { - return CHIP_ERROR_NOT_FOUND; - } - operationalPhase = mOperationalPhaseList[index]; - return CHIP_NO_ERROR; + return CHIP_ERROR_NOT_FOUND; } From 056942aaac1f5dab2461ca72eeee130cabe843c5 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 3 Jan 2024 17:05:17 +0000 Subject: [PATCH 10/26] Restyled by clang-format --- .../include/oven-operational-state-delegate.h | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index b523477dc8ec97..ea5935d8eb2d1d 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -79,7 +79,8 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate * Handle Command Callback in application: Pause * @param[out] get operational error after callback. */ - void HandlePauseStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + void HandlePauseStateCallback(Clusters::OperationalState::GenericOperationalError & err) override + { // This command in not supported. err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; @@ -88,7 +89,8 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate * Handle Command Callback in application: Resume * @param[out] get operational error after callback. */ - void HandleResumeStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + void HandleResumeStateCallback(Clusters::OperationalState::GenericOperationalError & err) override + { // This command in not supported. err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; @@ -97,7 +99,8 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate * Handle Command Callback in application: Start * @param[out] get operational error after callback. */ - void HandleStartStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + void HandleStartStateCallback(Clusters::OperationalState::GenericOperationalError & err) override + { // This command in not supported. err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; @@ -106,7 +109,8 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate * Handle Command Callback in application: Stop * @param[out] get operational error after callback. */ - void HandleStopStateCallback(Clusters::OperationalState::GenericOperationalError & err) override{ + void HandleStopStateCallback(Clusters::OperationalState::GenericOperationalError & err) override + { // This command in not supported. err.Set(to_underlying(ErrorStateEnum::kCommandInvalidInState)); }; From 4f43d6fcc5e01fb09b95d7db4d4ede013b2de423 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 12:47:39 -0600 Subject: [PATCH 11/26] regen zap --- .../all-clusters-app.matter | 89 +- .../all-clusters-common/all-clusters-app.zap | 70 +- .../zap-generated/CHIPInvokeCallbacks.cpp | 64 +- .../java/zap-generated/CHIPReadCallbacks.cpp | 1772 ++++++----------- 4 files changed, 744 insertions(+), 1251 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index ad7cb56245f2bd..2ac64212c6d7b3 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -2592,41 +2592,51 @@ cluster BooleanState = 69 { readonly attribute int16u clusterRevision = 65533; } -/** Attributes and commands for selecting a mode from a list of supported options. */ -provisional cluster OvenMode = 73 { +/** This cluster supports remotely monitoring and, where supported, changing the operational state of an Oven. */ +provisional cluster OvenCavityOperationalState = 72 { revision 1; - enum ModeTag : enum16 { - kBake = 16384; - kConvection = 16385; - kGrill = 16386; - kRoast = 16387; - kClean = 16388; - kConvectionBake = 16389; - kConvectionRoast = 16390; - kWarming = 16391; - kProofing = 16392; + enum ErrorStateEnum : enum8 { + kNoError = 0; + kUnableToStartOrResume = 1; + kUnableToCompleteOperation = 2; + kCommandInvalidInState = 3; } - bitmap Feature : bitmap32 { - kOnOff = 0x1; + enum OperationalStateEnum : enum8 { + kStopped = 0; + kRunning = 1; + kPaused = 2; + kError = 3; } - struct ModeTagStruct { - optional vendor_id mfgCode = 0; - enum16 value = 1; + struct ErrorStateStruct { + enum8 errorStateID = 0; + optional char_string<64> errorStateLabel = 1; + optional char_string<64> errorStateDetails = 2; } - struct ModeOptionStruct { - char_string<64> label = 0; - int8u mode = 1; - ModeTagStruct modeTags[] = 2; + struct OperationalStateStruct { + enum8 operationalStateID = 0; + optional char_string<64> operationalStateLabel = 1; } - readonly attribute ModeOptionStruct supportedModes[] = 0; - readonly attribute int8u currentMode = 1; - attribute optional nullable int8u startUpMode = 2; - attribute optional nullable int8u onMode = 3; + critical event OperationalError = 0 { + ErrorStateStruct errorState = 0; + } + + info event OperationCompletion = 1 { + enum8 completionErrorCode = 0; + optional nullable elapsed_s totalOperationalTime = 1; + optional nullable elapsed_s pausedTime = 2; + } + + readonly attribute nullable char_string phaseList[] = 0; + readonly attribute nullable int8u currentPhase = 1; + readonly attribute optional nullable elapsed_s countdownTime = 2; + readonly attribute OperationalStateStruct operationalStateList[] = 3; + readonly attribute OperationalStateEnum operationalState = 4; + readonly attribute ErrorStateStruct operationalError = 5; readonly attribute command_id generatedCommandList[] = 65528; readonly attribute command_id acceptedCommandList[] = 65529; readonly attribute event_id eventList[] = 65530; @@ -2634,18 +2644,18 @@ provisional cluster OvenMode = 73 { readonly attribute bitmap32 featureMap = 65532; readonly attribute int16u clusterRevision = 65533; - request struct ChangeToModeRequest { - int8u newMode = 0; - } - - response struct ChangeToModeResponse = 1 { - enum8 status = 0; - optional char_string statusText = 1; + response struct OperationalCommandResponse = 4 { + ErrorStateStruct commandResponseState = 0; } - /** This command is used to change device modes. - On receipt of this command the device SHALL respond with a ChangeToModeResponse command. */ - command ChangeToMode(ChangeToModeRequest): ChangeToModeResponse = 0; + /** Upon receipt, the device SHALL pause its operation if it is possible based on the current function of the server. */ + command Pause(): OperationalCommandResponse = 0; + /** Upon receipt, the device SHALL stop its operation if it is at a position where it is safe to do so and/or permitted. */ + command Stop(): OperationalCommandResponse = 1; + /** Upon receipt, the device SHALL start its operation if it is safe to do so and the device is in an operational state from which it can be started. */ + command Start(): OperationalCommandResponse = 2; + /** Upon receipt, the device SHALL resume its operation from the point it was at when it received the Pause command, or from the point when it was paused by means outside of this cluster (for example by manual button press). */ + command Resume(): OperationalCommandResponse = 3; } /** This cluster supports remotely monitoring and controling the different typs of @@ -7530,9 +7540,12 @@ endpoint 1 { ram attribute clusterRevision default = 1; } - server cluster OvenMode { - callback attribute supportedModes; - ram attribute currentMode; + server cluster OvenCavityOperationalState { + callback attribute phaseList; + callback attribute currentPhase; + callback attribute operationalStateList; + callback attribute operationalState; + callback attribute operationalError; callback attribute generatedCommandList; callback attribute acceptedCommandList; callback attribute eventList; diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap index 9013ea3140e6db..2a661532d30dc8 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap @@ -8457,16 +8457,16 @@ ] }, { - "name": "Oven Mode", - "code": 73, + "name": "Oven Cavity Operational State", + "code": 72, "mfgCode": null, - "define": "OVEN_MODE_CLUSTER", + "define": "OPERATIONAL_STATE_OVEN_CLUSTER", "side": "server", "enabled": 1, "apiMaturity": "provisional", "attributes": [ { - "name": "SupportedModes", + "name": "PhaseList", "code": 0, "mfgCode": null, "side": "server", @@ -8482,13 +8482,61 @@ "reportableChange": 0 }, { - "name": "CurrentMode", + "name": "CurrentPhase", "code": 1, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "RAM", + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "OperationalStateList", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "OperationalState", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "OperationalStateEnum", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "OperationalError", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "ErrorStateStruct", + "included": 1, + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -8613,7 +8661,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8645,7 +8693,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8661,7 +8709,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8677,7 +8725,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8693,7 +8741,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, diff --git a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp index 0a1171eab1635c..21ee0a8e5c300d 100644 --- a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp @@ -621,7 +621,7 @@ void CHIPGeneralCommissioningClusterArmFailSafeResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText); } CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback:: - CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) : +CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -638,8 +638,8 @@ CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback:: } } -CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback:: - ~CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback() +CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::~ +CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -688,7 +688,7 @@ void CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::Callbac env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText); } CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback:: - CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) : +CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -705,8 +705,8 @@ CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback:: } } -CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback:: - ~CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback() +CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::~ +CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -1596,7 +1596,7 @@ void CHIPOperationalCredentialsClusterAttestationResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, AttestationElements, AttestationSignature); } CHIPOperationalCredentialsClusterCertificateChainResponseCallback:: - CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) : +CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -1613,8 +1613,8 @@ CHIPOperationalCredentialsClusterCertificateChainResponseCallback:: } } -CHIPOperationalCredentialsClusterCertificateChainResponseCallback:: - ~CHIPOperationalCredentialsClusterCertificateChainResponseCallback() +CHIPOperationalCredentialsClusterCertificateChainResponseCallback::~ +CHIPOperationalCredentialsClusterCertificateChainResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -1995,7 +1995,7 @@ void CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, GroupKeySet); } CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback:: - CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) : +CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -2012,8 +2012,8 @@ CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback:: } } -CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback:: - ~CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback() +CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::~ +CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -2191,7 +2191,7 @@ void CHIPIcdManagementClusterStayActiveResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, PromisedActiveDuration); } CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback:: - CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback(jobject javaCallback) : +CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -2208,8 +2208,8 @@ CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback:: } } -CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback:: - ~CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback() +CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback::~ +CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -2455,7 +2455,7 @@ void CHIPLaundryWasherModeClusterChangeToModeResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, Status, StatusText); } CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback(jobject javaCallback) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -2472,8 +2472,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCa } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -2887,8 +2887,8 @@ CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::CHIPRvcOperati } } -CHIPRvcOperationalStateClusterOperationalCommandResponseCallback:: - ~CHIPRvcOperationalStateClusterOperationalCommandResponseCallback() +CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::~ +CHIPRvcOperationalStateClusterOperationalCommandResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6405,7 +6405,7 @@ void CHIPContentAppObserverClusterContentAppMessageResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, Status, Data, EncodingHint); } CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback:: - CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject javaCallback) : +CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -6422,8 +6422,8 @@ CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback:: } } -CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback:: - ~CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback() +CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::~ +CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6500,7 +6500,7 @@ void CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::Call env->CallVoidMethod(javaCallbackRef, javaMethod, profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes); } CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback:: - CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(jobject javaCallback) : +CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -6517,8 +6517,8 @@ CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback:: } } -CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback:: - ~CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback() +CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback::~ +CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -7456,7 +7456,7 @@ void CHIPUnitTestingClusterTestNullableOptionalResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, wasPresent, wasNull, value, originalValue); } CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback:: - CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCallback) : +CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -7473,8 +7473,8 @@ CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback:: } } -CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback:: - ~CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback() +CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback::~ +CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -8360,7 +8360,7 @@ void CHIPUnitTestingClusterTestEmitTestEventResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, value); } CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback:: - CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject javaCallback) : +CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -8377,8 +8377,8 @@ CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback:: } } -CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback:: - ~CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback() +CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback::~ +CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index 111a9bf547e544..30a86223102e40 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -939,7 +939,7 @@ void CHIPOnOffAttributeListAttributeCallback::CallbackFn(void * context, } CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback:: - CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -957,8 +957,8 @@ CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback:: } } -CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback:: - ~CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback() +CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback::~ +CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -1030,8 +1030,8 @@ CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::CHIPOnOffSwitc } } -CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback:: - ~CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback() +CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::~ +CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5071,7 +5071,7 @@ void CHIPBasicInformationAttributeListAttributeCallback::CallbackFn( } CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback:: - CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5089,8 +5089,8 @@ CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback:: } } -CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback:: - ~CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::~ +CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5144,7 +5144,7 @@ void CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::Callbac } CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback:: - CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5162,8 +5162,8 @@ CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback:: } } -CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback:: - ~CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback::~ +CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5361,7 +5361,7 @@ void CHIPOtaSoftwareUpdateProviderAttributeListAttributeCallback::CallbackFn( } CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback:: - CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5379,8 +5379,8 @@ CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback:: } } -CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback:: - ~CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback() +CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::~ +CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5475,7 +5475,7 @@ void CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::Callbac } CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback:: - CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5493,8 +5493,8 @@ CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback:: } } -CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback:: - ~CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback() +CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::~ +CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5544,7 +5544,7 @@ void CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::Callbac } CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback:: - CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5562,8 +5562,8 @@ CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback:: } } -CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback:: - ~CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::~ +CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5617,7 +5617,7 @@ void CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::Callba } CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback:: - CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5635,8 +5635,8 @@ CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback:: } } -CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback:: - ~CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback::~ +CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5902,7 +5902,7 @@ void CHIPLocalizationConfigurationSupportedLocalesAttributeCallback::CallbackFn( } CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback:: - CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5920,8 +5920,8 @@ CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback:: } } -CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback:: - ~CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback() +CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::~ +CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5975,7 +5975,7 @@ void CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::Callbac } CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback:: - CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5993,8 +5993,8 @@ CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback:: } } -CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback:: - ~CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback() +CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback::~ +CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6192,7 +6192,7 @@ void CHIPLocalizationConfigurationAttributeListAttributeCallback::CallbackFn( } CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback:: - CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -6210,8 +6210,8 @@ CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback:: } } -CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback:: - ~CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback() +CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback::~ +CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6911,7 +6911,7 @@ void CHIPPowerSourceConfigurationSourcesAttributeCallback::CallbackFn( } CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback:: - CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -6929,8 +6929,8 @@ CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback:: } } -CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback:: - ~CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback() +CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback::~ +CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -7002,8 +7002,8 @@ CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::CHIPPowerSourc } } -CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback:: - ~CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback() +CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::~ +CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12104,7 +12104,7 @@ void CHIPThreadNetworkDiagnosticsChannelPage0MaskAttributeCallback::CallbackFn( } CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback:: - CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -12122,8 +12122,8 @@ CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback:: } } -CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback:: - ~CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback() +CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::~ +CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12178,7 +12178,7 @@ void CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::Callb } CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback:: - CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -12196,8 +12196,8 @@ CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback:: } } -CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback:: - ~CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback() +CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback::~ +CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12269,8 +12269,8 @@ CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::CHIPThreadNetw } } -CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback:: - ~CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback() +CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::~ +CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12941,7 +12941,7 @@ void CHIPWiFiNetworkDiagnosticsBeaconRxCountAttributeCallback::CallbackFn(void * } CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback:: - CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -12959,8 +12959,8 @@ CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback:: } } -CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback:: - ~CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback() +CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::~ +CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -13010,7 +13010,7 @@ void CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::Callback } CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback:: - CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -13028,8 +13028,8 @@ CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback:: } } -CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback:: - ~CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback() +CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback::~ +CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -13843,7 +13843,7 @@ void CHIPEthernetNetworkDiagnosticsCarrierDetectAttributeCallback::CallbackFn(vo } CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback:: - CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -13861,8 +13861,8 @@ CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback:: } } -CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback:: - ~CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback() +CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::~ +CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -13916,7 +13916,7 @@ void CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::Callba } CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback:: - CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -13934,8 +13934,8 @@ CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback:: } } -CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback:: - ~CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback() +CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback::~ +CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -14851,7 +14851,7 @@ void CHIPTimeSynchronizationAttributeListAttributeCallback::CallbackFn( } CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback:: - CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -14869,8 +14869,8 @@ CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback:: } } -CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback:: - ~CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback() +CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::~ +CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -14924,7 +14924,7 @@ void CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::Cal } CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback:: - CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -14942,8 +14942,8 @@ CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback:: } } -CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback:: - ~CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback() +CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback::~ +CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -15559,7 +15559,7 @@ void CHIPAdministratorCommissioningAdminVendorIdAttributeCallback::CallbackFn( } CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback:: - CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -15577,8 +15577,8 @@ CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback:: } } -CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback:: - ~CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback() +CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::~ +CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -15632,7 +15632,7 @@ void CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::Callba } CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback:: - CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -15650,8 +15650,8 @@ CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback:: } } -CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback:: - ~CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback() +CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback::~ +CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -16090,7 +16090,7 @@ void CHIPOperationalCredentialsFabricsAttributeCallback::CallbackFn( } CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback:: - CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -16108,8 +16108,8 @@ CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback:: } } -CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback:: - ~CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback() +CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback::~ +CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -19751,7 +19751,7 @@ void CHIPOvenCavityOperationalStateCountdownTimeAttributeCallback::CallbackFn( } CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback:: - CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -19769,8 +19769,8 @@ CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback:: } } -CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback:: - ~CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback() +CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback::~ +CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -19864,7 +19864,7 @@ void CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback::Callba } CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback:: - CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -19882,8 +19882,8 @@ CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback:: } } -CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback:: - ~CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback() +CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback::~ +CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -19937,7 +19937,7 @@ void CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback::Callba } CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback:: - CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -19955,8 +19955,8 @@ CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback:: } } -CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback:: - ~CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback() +CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback::~ +CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22337,7 +22337,7 @@ void CHIPLaundryWasherModeAttributeListAttributeCallback::CallbackFn( } CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22356,8 +22356,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallba } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22502,7 +22502,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeC } CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -22521,8 +22521,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback: } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22573,7 +22573,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCall } CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -22592,8 +22592,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback:: } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22644,7 +22644,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback: } CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22663,8 +22663,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttribute } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22721,7 +22721,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttr } CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22740,8 +22740,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeC } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22798,7 +22798,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttri } CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -22817,8 +22817,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback:: } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22873,7 +22873,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallba } CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback:: - CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22892,8 +22892,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallbac } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback:: - ~CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback::~ +CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -24444,7 +24444,7 @@ void CHIPRvcCleanModeAttributeListAttributeCallback::CallbackFn(void * context, } CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback:: - CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -24462,8 +24462,8 @@ CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback:: } } -CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback:: - ~CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback() +CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback::~ +CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29467,7 +29467,7 @@ void CHIPHepaFilterMonitoringAttributeListAttributeCallback::CallbackFn( } CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback:: - CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29485,8 +29485,8 @@ CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback:: } } -CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback:: - ~CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback() +CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::~ +CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29536,7 +29536,7 @@ void CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::Callba } CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback:: - CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -29555,8 +29555,8 @@ CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback:: } } -CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback:: - ~CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback::~ +CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29642,7 +29642,7 @@ void CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback: } CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback:: - CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29660,8 +29660,8 @@ CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback:: } } -CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback:: - ~CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::~ +CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29715,7 +29715,7 @@ void CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::C } CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback:: - CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29733,8 +29733,8 @@ CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback:: } } -CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback:: - ~CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback::~ +CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29860,7 +29860,7 @@ void CHIPActivatedCarbonFilterMonitoringEventListAttributeCallback::CallbackFn( } CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback:: - CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29878,8 +29878,8 @@ CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback:: } } -CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback:: - ~CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::~ +CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29933,7 +29933,7 @@ void CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::Callback } CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback:: - CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29951,8 +29951,8 @@ CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback:: } } -CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback:: - ~CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback() +CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback::~ +CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30006,7 +30006,7 @@ void CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback::Callbac } CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback:: - CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30024,8 +30024,8 @@ CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback:: } } -CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback:: - ~CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback() +CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback::~ +CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30291,7 +30291,7 @@ void CHIPValveConfigurationAndControlOpenDurationAttributeCallback::CallbackFn( } CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback:: - CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30309,8 +30309,8 @@ CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback:: } } -CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback:: - ~CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback() +CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback::~ +CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30428,7 +30428,7 @@ void CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback::CallbackFn( } CHIPValveConfigurationAndControlRemainingDurationAttributeCallback:: - CHIPValveConfigurationAndControlRemainingDurationAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30446,8 +30446,8 @@ CHIPValveConfigurationAndControlRemainingDurationAttributeCallback:: } } -CHIPValveConfigurationAndControlRemainingDurationAttributeCallback:: - ~CHIPValveConfigurationAndControlRemainingDurationAttributeCallback() +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback::~ +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30769,7 +30769,7 @@ void CHIPValveConfigurationAndControlTargetLevelAttributeCallback::CallbackFn( } CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback:: - CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30787,8 +30787,8 @@ CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback:: } } -CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback:: - ~CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback() +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback::~ +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30842,7 +30842,7 @@ void CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback::Call } CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback:: - CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30860,8 +30860,8 @@ CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback:: } } -CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback:: - ~CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback() +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback::~ +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -31059,7 +31059,7 @@ void CHIPValveConfigurationAndControlAttributeListAttributeCallback::CallbackFn( } CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback:: - CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -31077,8 +31077,8 @@ CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback() +CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback::~ +CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -31132,7 +31132,7 @@ void CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback::Callb } CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback:: - CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -31150,8 +31150,8 @@ CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback() +CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback::~ +CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -31349,7 +31349,7 @@ void CHIPElectricalEnergyMeasurementAttributeListAttributeCallback::CallbackFn( } CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback:: - CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -31367,8 +31367,8 @@ CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback:: } } -CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback:: - ~CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback() +CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback::~ +CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -32625,7 +32625,7 @@ void CHIPDemandResponseLoadControlActiveEventsAttributeCallback::CallbackFn( } CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback:: - CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -32643,8 +32643,8 @@ CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback:: } } -CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback:: - ~CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback() +CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback::~ +CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -32698,7 +32698,7 @@ void CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback::Callbac } CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback:: - CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -32716,8 +32716,8 @@ CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback:: } } -CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback:: - ~CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback() +CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback::~ +CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -32915,7 +32915,7 @@ void CHIPDemandResponseLoadControlAttributeListAttributeCallback::CallbackFn( } CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback:: - CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -32933,8 +32933,8 @@ CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback:: } } -CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback:: - ~CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback() +CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback::~ +CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -34401,718 +34401,9 @@ void CHIPEnergyEvseGeneratedCommandListAttributeCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } -CHIPEnergyEvseAcceptedCommandListAttributeCallback::CHIPEnergyEvseAcceptedCommandListAttributeCallback(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"); - } -} - -CHIPEnergyEvseAcceptedCommandListAttributeCallback::~CHIPEnergyEvseAcceptedCommandListAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyEvseAcceptedCommandListAttributeCallback::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->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); -} - -CHIPEnergyEvseEventListAttributeCallback::CHIPEnergyEvseEventListAttributeCallback(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"); - } -} - -CHIPEnergyEvseEventListAttributeCallback::~CHIPEnergyEvseEventListAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyEvseEventListAttributeCallback::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->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); -} - -CHIPEnergyEvseAttributeListAttributeCallback::CHIPEnergyEvseAttributeListAttributeCallback(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"); - } -} - -CHIPEnergyEvseAttributeListAttributeCallback::~CHIPEnergyEvseAttributeListAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyEvseAttributeListAttributeCallback::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->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); -} - -CHIPEnergyPreferenceEnergyBalancesAttributeCallback::CHIPEnergyPreferenceEnergyBalancesAttributeCallback(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"); - } -} - -CHIPEnergyPreferenceEnergyBalancesAttributeCallback::~CHIPEnergyPreferenceEnergyBalancesAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyPreferenceEnergyBalancesAttributeCallback::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->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; - jobject newElement_0_step; - std::string newElement_0_stepClassName = "java/lang/Integer"; - std::string newElement_0_stepCtorSignature = "(I)V"; - jint jninewElement_0_step = static_cast(entry_0.step); - chip::JniReferences::GetInstance().CreateBoxedObject( - newElement_0_stepClassName.c_str(), newElement_0_stepCtorSignature.c_str(), jninewElement_0_step, newElement_0_step); - jobject newElement_0_label; - if (!entry_0.label.HasValue()) - { - chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_label); - } - else - { - jobject newElement_0_labelInsideOptional; - LogErrorOnFailure( - chip::JniReferences::GetInstance().CharToStringUTF(entry_0.label.Value(), newElement_0_labelInsideOptional)); - chip::JniReferences::GetInstance().CreateOptional(newElement_0_labelInsideOptional, newElement_0_label); - } - - jclass balanceStructStructClass_1; - err = chip::JniReferences::GetInstance().GetClassRef( - env, "chip/devicecontroller/ChipStructs$EnergyPreferenceClusterBalanceStruct", balanceStructStructClass_1); - if (err != CHIP_NO_ERROR) - { - ChipLogError(Zcl, "Could not find class ChipStructs$EnergyPreferenceClusterBalanceStruct"); - return; - } - - jmethodID balanceStructStructCtor_1; - err = chip::JniReferences::GetInstance().FindMethod( - env, balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V", &balanceStructStructCtor_1); - if (err != CHIP_NO_ERROR || balanceStructStructCtor_1 == nullptr) - { - ChipLogError(Zcl, "Could not find ChipStructs$EnergyPreferenceClusterBalanceStruct constructor"); - return; - } - - newElement_0 = env->NewObject(balanceStructStructClass_1, balanceStructStructCtor_1, newElement_0_step, newElement_0_label); - chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); - } - - env->ExceptionClear(); - env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); -} - -CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback(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"); - } -} - -CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::~CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::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->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/Integer"; - std::string newElement_0CtorSignature = "(I)V"; - jint 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); -} - -CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback( - 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"); - } -} - -CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::~CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::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->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; - jobject newElement_0_step; - std::string newElement_0_stepClassName = "java/lang/Integer"; - std::string newElement_0_stepCtorSignature = "(I)V"; - jint jninewElement_0_step = static_cast(entry_0.step); - chip::JniReferences::GetInstance().CreateBoxedObject( - newElement_0_stepClassName.c_str(), newElement_0_stepCtorSignature.c_str(), jninewElement_0_step, newElement_0_step); - jobject newElement_0_label; - if (!entry_0.label.HasValue()) - { - chip::JniReferences::GetInstance().CreateOptional(nullptr, newElement_0_label); - } - else - { - jobject newElement_0_labelInsideOptional; - LogErrorOnFailure( - chip::JniReferences::GetInstance().CharToStringUTF(entry_0.label.Value(), newElement_0_labelInsideOptional)); - chip::JniReferences::GetInstance().CreateOptional(newElement_0_labelInsideOptional, newElement_0_label); - } - - jclass balanceStructStructClass_1; - err = chip::JniReferences::GetInstance().GetClassRef( - env, "chip/devicecontroller/ChipStructs$EnergyPreferenceClusterBalanceStruct", balanceStructStructClass_1); - if (err != CHIP_NO_ERROR) - { - ChipLogError(Zcl, "Could not find class ChipStructs$EnergyPreferenceClusterBalanceStruct"); - return; - } - - jmethodID balanceStructStructCtor_1; - err = chip::JniReferences::GetInstance().FindMethod( - env, balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V", &balanceStructStructCtor_1); - if (err != CHIP_NO_ERROR || balanceStructStructCtor_1 == nullptr) - { - ChipLogError(Zcl, "Could not find ChipStructs$EnergyPreferenceClusterBalanceStruct constructor"); - return; - } - - newElement_0 = env->NewObject(balanceStructStructClass_1, balanceStructStructCtor_1, newElement_0_step, newElement_0_label); - chip::JniReferences::GetInstance().AddToList(arrayListObj, newElement_0); - } - - env->ExceptionClear(); - env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); -} - -CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::CHIPEnergyPreferenceGeneratedCommandListAttributeCallback( - 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"); - } -} - -CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::~CHIPEnergyPreferenceGeneratedCommandListAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::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->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); -} - -CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::CHIPEnergyPreferenceAcceptedCommandListAttributeCallback( - 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"); - } -} - -CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::~CHIPEnergyPreferenceAcceptedCommandListAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::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->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); -} - -CHIPEnergyPreferenceEventListAttributeCallback::CHIPEnergyPreferenceEventListAttributeCallback(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"); - } -} - -CHIPEnergyPreferenceEventListAttributeCallback::~CHIPEnergyPreferenceEventListAttributeCallback() -{ - JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); - if (env == nullptr) - { - ChipLogError(Zcl, "Could not delete global reference for Java callback"); - return; - } - env->DeleteGlobalRef(javaCallbackRef); -} - -void CHIPEnergyPreferenceEventListAttributeCallback::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->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); -} - -CHIPEnergyPreferenceAttributeListAttributeCallback::CHIPEnergyPreferenceAttributeListAttributeCallback(jobject javaCallback, +CHIPEnergyEvseAcceptedCommandListAttributeCallback::CHIPEnergyEvseAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : - chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -35128,7 +34419,7 @@ CHIPEnergyPreferenceAttributeListAttributeCallback::CHIPEnergyPreferenceAttribut } } -CHIPEnergyPreferenceAttributeListAttributeCallback::~CHIPEnergyPreferenceAttributeListAttributeCallback() +CHIPEnergyEvseAcceptedCommandListAttributeCallback::~CHIPEnergyEvseAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -35139,8 +34430,8 @@ CHIPEnergyPreferenceAttributeListAttributeCallback::~CHIPEnergyPreferenceAttribu env->DeleteGlobalRef(javaCallbackRef); } -void CHIPEnergyPreferenceAttributeListAttributeCallback::CallbackFn( - void * context, const chip::app::DataModel::DecodableList & list) +void CHIPEnergyEvseAcceptedCommandListAttributeCallback::CallbackFn( + void * context, const chip::app::DataModel::DecodableList & list) { chip::DeviceLayer::StackUnlock unlock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -35149,8 +34440,148 @@ void CHIPEnergyPreferenceAttributeListAttributeCallback::CallbackFn( VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); - std::unique_ptr cppCallback( - reinterpret_cast(context), maybeDestroy); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback->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); +} + +CHIPEnergyEvseEventListAttributeCallback::CHIPEnergyEvseEventListAttributeCallback(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"); + } +} + +CHIPEnergyEvseEventListAttributeCallback::~CHIPEnergyEvseEventListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyEvseEventListAttributeCallback::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->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); +} + +CHIPEnergyEvseAttributeListAttributeCallback::CHIPEnergyEvseAttributeListAttributeCallback(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"); + } +} + +CHIPEnergyEvseAttributeListAttributeCallback::~CHIPEnergyEvseAttributeListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPEnergyEvseAttributeListAttributeCallback::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->javaCallbackRef; @@ -35225,7 +34656,7 @@ void CHIPEnergyPreferenceEnergyBalancesAttributeCallback::CallbackFn( 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -35268,9 +34699,11 @@ void CHIPEnergyPreferenceEnergyBalancesAttributeCallback::CallbackFn( ChipLogError(Zcl, "Could not find class ChipStructs$EnergyPreferenceClusterBalanceStruct"); return; } - jmethodID balanceStructStructCtor_1 = - env->GetMethodID(balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V"); - if (balanceStructStructCtor_1 == nullptr) + + jmethodID balanceStructStructCtor_1; + err = chip::JniReferences::GetInstance().FindMethod( + env, balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V", &balanceStructStructCtor_1); + if (err != CHIP_NO_ERROR || balanceStructStructCtor_1 == nullptr) { ChipLogError(Zcl, "Could not find ChipStructs$EnergyPreferenceClusterBalanceStruct constructor"); return; @@ -35328,7 +34761,7 @@ void CHIPEnergyPreferenceEnergyPrioritiesAttributeCallback::CallbackFn( 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -35401,7 +34834,7 @@ void CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::CallbackFn( 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -35444,9 +34877,11 @@ void CHIPEnergyPreferenceLowPowerModeSensitivitiesAttributeCallback::CallbackFn( ChipLogError(Zcl, "Could not find class ChipStructs$EnergyPreferenceClusterBalanceStruct"); return; } - jmethodID balanceStructStructCtor_1 = - env->GetMethodID(balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V"); - if (balanceStructStructCtor_1 == nullptr) + + jmethodID balanceStructStructCtor_1; + err = chip::JniReferences::GetInstance().FindMethod( + env, balanceStructStructClass_1, "", "(Ljava/lang/Integer;Ljava/util/Optional;)V", &balanceStructStructCtor_1); + if (err != CHIP_NO_ERROR || balanceStructStructCtor_1 == nullptr) { ChipLogError(Zcl, "Could not find ChipStructs$EnergyPreferenceClusterBalanceStruct constructor"); return; @@ -35504,7 +34939,7 @@ void CHIPEnergyPreferenceGeneratedCommandListAttributeCallback::CallbackFn( 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -35576,7 +35011,7 @@ void CHIPEnergyPreferenceAcceptedCommandListAttributeCallback::CallbackFn( 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -35647,7 +35082,7 @@ void CHIPEnergyPreferenceEventListAttributeCallback::CallbackFn(void * context, 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -35718,7 +35153,7 @@ void CHIPEnergyPreferenceAttributeListAttributeCallback::CallbackFn( 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; + javaCallbackRef = cppCallback->javaCallbackRef; VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); @@ -36661,8 +36096,8 @@ CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::CHIPWindowCove } } -CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback:: - ~CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback() +CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::~ +CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36730,8 +36165,8 @@ CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::CHIPWindowCove } } -CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback:: - ~CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback() +CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::~ +CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36781,7 +36216,7 @@ void CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::CallbackF } CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback:: - CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36799,8 +36234,8 @@ CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback:: } } -CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback:: - ~CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback() +CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::~ +CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36850,7 +36285,7 @@ void CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::Callbac } CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback:: - CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36868,8 +36303,8 @@ CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback:: } } -CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback:: - ~CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback() +CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::~ +CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36919,7 +36354,7 @@ void CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::Callbac } CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback:: - CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36937,8 +36372,8 @@ CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback:: } } -CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback:: - ~CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback() +CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::~ +CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36988,7 +36423,7 @@ void CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::Callba } CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback:: - CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -37006,8 +36441,8 @@ CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback:: } } -CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback:: - ~CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback() +CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback::~ +CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -37849,8 +37284,8 @@ CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::CHIPPumpConfig } } -CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback:: - ~CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback() +CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::~ +CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -37918,8 +37353,8 @@ CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::CHIPPumpConfig } } -CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback:: - ~CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback() +CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::~ +CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38649,7 +38084,7 @@ void CHIPPumpConfigurationAndControlSpeedAttributeCallback::CallbackFn(void * co } CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback:: - CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38667,8 +38102,8 @@ CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback:: } } -CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback:: - ~CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback() +CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback::~ +CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38786,7 +38221,7 @@ void CHIPPumpConfigurationAndControlPowerAttributeCallback::CallbackFn(void * co } CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback:: - CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38804,8 +38239,8 @@ CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback:: } } -CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback:: - ~CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback() +CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::~ +CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38855,7 +38290,7 @@ void CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::Cal } CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback:: - CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38873,8 +38308,8 @@ CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback:: } } -CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback:: - ~CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback() +CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::~ +CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38928,7 +38363,7 @@ void CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::Callb } CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback:: - CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38946,8 +38381,8 @@ CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback:: } } -CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback:: - ~CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback() +CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback::~ +CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41524,7 +40959,7 @@ void CHIPFanControlAttributeListAttributeCallback::CallbackFn(void * context, } CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback:: - CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -41543,8 +40978,8 @@ CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback:: } } -CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback:: - ~CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback::~ +CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41599,7 +41034,7 @@ void CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallba } CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback:: - CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -41618,8 +41053,8 @@ CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback:: } } -CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback:: - ~CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback::~ +CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41674,7 +41109,7 @@ void CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallbac } CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback:: - CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -41692,8 +41127,8 @@ CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback:: } } -CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback:: - ~CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::~ +CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41747,7 +41182,7 @@ void CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::Callbac } CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback:: - CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -41765,8 +41200,8 @@ CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback:: } } -CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback:: - ~CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::~ +CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -42932,8 +42367,8 @@ CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::CHIPBallastCon } } -CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback:: - ~CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback() +CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::~ +CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45794,8 +45229,8 @@ CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::CHIPRelativeHu } } -CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback() +CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::~ +CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45863,8 +45298,8 @@ CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::CHIPRelativeHu } } -CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback() +CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45914,7 +45349,7 @@ void CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::CallbackF } CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback:: - CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -45932,8 +45367,8 @@ CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback() +CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::~ +CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45987,7 +45422,7 @@ void CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::Callb } CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback:: - CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -46005,8 +45440,8 @@ CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback() +CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback::~ +CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46490,7 +45925,7 @@ void CHIPOccupancySensingAttributeListAttributeCallback::CallbackFn( } CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -46508,8 +45943,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46559,7 +45994,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::C } CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46578,8 +46013,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46630,7 +46065,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback } CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46649,8 +46084,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46701,7 +46136,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback } CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46720,8 +46155,8 @@ CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46772,7 +46207,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallbac } CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46791,8 +46226,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback: } } -CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46843,7 +46278,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCall } CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46862,8 +46297,8 @@ CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback: } } -CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46918,7 +46353,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCall } CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46937,8 +46372,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46993,7 +46428,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallb } CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47011,8 +46446,8 @@ CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47066,7 +46501,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::Callb } CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback:: - CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47084,8 +46519,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback:: } } -CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback:: - ~CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::~ +CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47139,7 +46574,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::C } CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47157,8 +46592,8 @@ CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47208,7 +46643,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::Ca } CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47227,8 +46662,8 @@ CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47279,7 +46714,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback: } CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47298,8 +46733,8 @@ CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47350,7 +46785,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback: } CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47369,8 +46804,8 @@ CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47421,7 +46856,7 @@ void CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback } CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47440,8 +46875,8 @@ CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47492,7 +46927,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallb } CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47511,8 +46946,8 @@ CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47567,7 +47002,7 @@ void CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallb } CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47586,8 +47021,8 @@ CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47642,7 +47077,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallba } CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47660,8 +47095,8 @@ CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47715,7 +47150,7 @@ void CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::Callba } CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback:: - CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47733,8 +47168,8 @@ CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback:: } } -CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback:: - ~CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::~ +CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47788,7 +47223,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::Ca } CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47807,8 +47242,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: } } -CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47858,7 +47293,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: } CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47877,8 +47312,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47929,7 +47364,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallbac } CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47948,8 +47383,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48000,7 +47435,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallbac } CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -48019,8 +47454,8 @@ CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48071,7 +47506,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallba } CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -48090,8 +47525,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback } } -CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48142,7 +47577,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCal } CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -48161,8 +47596,8 @@ CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback } } -CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48217,7 +47652,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCal } CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -48236,8 +47671,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback: } } -CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48292,7 +47727,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCall } CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48310,8 +47745,8 @@ CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback:: } } -CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48365,7 +47800,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::Call } CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback:: - CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -48384,8 +47819,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback:: } } -CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback:: - ~CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback::~ +CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48507,7 +47942,7 @@ void CHIPOzoneConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn } CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48525,8 +47960,8 @@ CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48576,7 +48011,7 @@ void CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::Callbac } CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48594,8 +48029,8 @@ CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48645,7 +48080,7 @@ void CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callbac } CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48663,8 +48098,8 @@ CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48714,7 +48149,7 @@ void CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callba } CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48732,8 +48167,8 @@ CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48783,7 +48218,7 @@ void CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::Cal } CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48801,8 +48236,8 @@ CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48856,7 +48291,7 @@ void CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::Cal } CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48874,8 +48309,8 @@ CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49141,7 +48576,7 @@ void CHIPPm25ConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn( } CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49159,8 +48594,8 @@ CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49210,7 +48645,7 @@ void CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::Callback } CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49228,8 +48663,8 @@ CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49279,7 +48714,7 @@ void CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callback } CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49297,8 +48732,8 @@ CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49348,7 +48783,7 @@ void CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callbac } CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49366,8 +48801,8 @@ CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49417,7 +48852,7 @@ void CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Call } CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49435,8 +48870,8 @@ CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49490,7 +48925,7 @@ void CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::Call } CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49508,8 +48943,8 @@ CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49707,7 +49142,7 @@ void CHIPPm25ConcentrationMeasurementAttributeListAttributeCallback::CallbackFn( } CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49725,8 +49160,8 @@ CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49776,7 +49211,7 @@ void CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::Cal } CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49795,8 +49230,8 @@ CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49846,7 +49281,7 @@ void CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: } CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49865,8 +49300,8 @@ CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49916,7 +49351,7 @@ void CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49935,8 +49370,8 @@ CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49987,7 +49422,7 @@ void CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback: } CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -50006,8 +49441,8 @@ CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50058,7 +49493,7 @@ void CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallba } CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -50077,8 +49512,8 @@ CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50133,7 +49568,7 @@ void CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallba } CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -50152,8 +49587,8 @@ CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50208,7 +49643,7 @@ void CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallbac } CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50226,8 +49661,8 @@ CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50281,7 +49716,7 @@ void CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::Callbac } CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback:: - CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50299,8 +49734,8 @@ CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback:: } } -CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback:: - ~CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback::~ +CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50440,8 +49875,8 @@ CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::CHIPPm1Concent } } -CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50509,8 +49944,8 @@ CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::CHIPPm1Concent } } -CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50560,7 +49995,7 @@ void CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::CallbackF } CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50578,8 +50013,8 @@ CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50629,7 +50064,7 @@ void CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callback } CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50647,8 +50082,8 @@ CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50698,7 +50133,7 @@ void CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Callb } CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50716,8 +50151,8 @@ CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50771,7 +50206,7 @@ void CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::Callb } CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50789,8 +50224,8 @@ CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51056,7 +50491,7 @@ void CHIPPm10ConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn( } CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51074,8 +50509,8 @@ CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51125,7 +50560,7 @@ void CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::Callback } CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51143,8 +50578,8 @@ CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51194,7 +50629,7 @@ void CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callback } CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51212,8 +50647,8 @@ CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51263,7 +50698,7 @@ void CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callbac } CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51281,8 +50716,8 @@ CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51332,7 +50767,7 @@ void CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Call } CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51350,8 +50785,8 @@ CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51405,7 +50840,7 @@ void CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::Call } CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51423,8 +50858,8 @@ CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51622,7 +51057,7 @@ void CHIPPm10ConcentrationMeasurementAttributeListAttributeCallback::CallbackFn( } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51641,8 +51076,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeC } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51695,8 +51130,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttri } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, - bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51715,8 +51149,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttribu } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51769,8 +51203,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAt } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, - bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51789,8 +51222,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttribu } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51843,8 +51276,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAt } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, - bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive) @@ -51863,8 +51295,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttrib } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51917,8 +51349,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueA } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, - bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this), @@ -51938,8 +51370,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAtt } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51993,8 +51425,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredVal } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, - bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), @@ -52014,8 +51446,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAtt } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52073,8 +51505,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandLi } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, - bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive) @@ -52093,8 +51525,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttr } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52152,7 +51584,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandLis } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -52171,8 +51603,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallb } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52228,7 +51660,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttribute } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback:: - CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -52247,8 +51679,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeC } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback:: - ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback::~ +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52373,7 +51805,7 @@ void CHIPRadonConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn } CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback:: - CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52391,8 +51823,8 @@ CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback:: } } -CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback:: - ~CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::~ +CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52442,7 +51874,7 @@ void CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::Callbac } CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52460,8 +51892,8 @@ CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } } -CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback:: - ~CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ +CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52511,7 +51943,7 @@ void CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callbac } CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52529,8 +51961,8 @@ CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback:: } } -CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback:: - ~CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ +CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52580,7 +52012,7 @@ void CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callba } CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52598,8 +52030,8 @@ CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback:: } } -CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback:: - ~CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ +CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52649,7 +52081,7 @@ void CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::Cal } CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback:: - CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52667,8 +52099,8 @@ CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback:: } } -CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback:: - ~CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::~ +CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52722,7 +52154,7 @@ void CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::Cal } CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback:: - CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52740,8 +52172,8 @@ CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback:: } } -CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback:: - ~CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback::~ +CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) From f842076b5019207bcb5e3027ae8b7272b2cf97be Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 12:49:08 -0600 Subject: [PATCH 12/26] Update for changes in PR31176 --- .../include/oven-operational-state-delegate.h | 10 +++------- .../src/oven-operational-state-delegate.cpp | 2 +- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index ea5935d8eb2d1d..987b9585059240 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -40,10 +40,6 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kError)), }; - const Clusters::OperationalState::GenericOperationalPhase mOperationalPhaseList[1] = { - // Phase List is null - OperationalState::GenericOperationalPhase(DataModel::Nullable()), - }; public: /** @@ -64,15 +60,15 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate Clusters::OperationalState::GenericOperationalState & operationalState) override; /** - * Fills in the provided GenericOperationalPhase with the phase at index `index` if there is one, + * Fills in the provided MutableCharSpan with the phase at index `index` if there is one, * or returns CHIP_ERROR_NOT_FOUND if the index is out of range for the list of phases. * Note: This is used by the SDK to populate the phase list attribute. If the contents of this list changes, the * device SHALL call the Instance's ReportPhaseListChange method to report that this attribute has changed. * @param index The index of the phase, with 0 representing the first phase. - * @param operationalPhase The GenericOperationalPhase is filled. + * @param operationalPhase The MutableCharSpan is filled. */ CHIP_ERROR GetOperationalPhaseAtIndex(size_t index, - Clusters::OperationalState::GenericOperationalPhase & operationalPhase) override; + Clusters::OperationalState::MutableCharSpan & operationalPhase) override; // command callback /** diff --git a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp index 9cfd86db206895..de80d526e7ad8d 100644 --- a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp @@ -68,7 +68,7 @@ OvenCavityOperationalStateDelegate::GetOperationalStateAtIndex(size_t index, CHIP_ERROR OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, - OperationalState::GenericOperationalPhase & operationalPhase) + OperationalState::MutableCharSpan & operationalPhase) { return CHIP_ERROR_NOT_FOUND; } From ef4af0259a0577c045b275b37c35fc25efcd2d69 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 13:52:26 -0600 Subject: [PATCH 13/26] fix build errors --- .../include/oven-operational-state-delegate.h | 3 +-- .../src/oven-operational-state-delegate.cpp | 3 +-- examples/all-clusters-app/esp32/main/CMakeLists.txt | 1 - 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index 987b9585059240..c1569d36fa40bc 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -67,8 +67,7 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate * @param index The index of the phase, with 0 representing the first phase. * @param operationalPhase The MutableCharSpan is filled. */ - CHIP_ERROR GetOperationalPhaseAtIndex(size_t index, - Clusters::OperationalState::MutableCharSpan & operationalPhase) override; + CHIP_ERROR GetOperationalPhaseAtIndex(size_t index, MutableCharSpan & operationalPhase) override; // command callback /** diff --git a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp index de80d526e7ad8d..ecae5c88006ef4 100644 --- a/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/oven-operational-state-delegate.cpp @@ -67,8 +67,7 @@ OvenCavityOperationalStateDelegate::GetOperationalStateAtIndex(size_t index, } CHIP_ERROR -OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, - OperationalState::MutableCharSpan & operationalPhase) +OvenCavityOperationalStateDelegate::GetOperationalPhaseAtIndex(size_t index, MutableCharSpan & operationalPhase) { return CHIP_ERROR_NOT_FOUND; } diff --git a/examples/all-clusters-app/esp32/main/CMakeLists.txt b/examples/all-clusters-app/esp32/main/CMakeLists.txt index 3ee8c1e6e243a7..896f714bcf973b 100644 --- a/examples/all-clusters-app/esp32/main/CMakeLists.txt +++ b/examples/all-clusters-app/esp32/main/CMakeLists.txt @@ -92,7 +92,6 @@ set(SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/dishwasher-alarm-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/laundry-washer-controls-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/laundry-dryer-controls-server" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/operational-state-oven-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/src" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/electrical-energy-measurement-server" ) From 67027ba7190cbb918bd65f6d2422e279ac5f4901 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 9 Jan 2024 19:53:12 +0000 Subject: [PATCH 14/26] Restyled by clang-format --- .../include/oven-operational-state-delegate.h | 1 - 1 file changed, 1 deletion(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index c1569d36fa40bc..f3313030ac7ba4 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -40,7 +40,6 @@ class OvenCavityOperationalStateDelegate : public OperationalState::Delegate OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kError)), }; - public: /** * Get the countdown time. This attribute is not supported in our example app. From 4146b70c67ee42bc0efab6c4169c947d8cf8792f Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 16:10:05 -0600 Subject: [PATCH 15/26] zap regen --- .../java/zap-generated/CHIPReadCallbacks.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index 30a86223102e40..be1f44d6ab4edf 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -35448,7 +35448,7 @@ void CHIPDoorLockAliroReaderGroupIdentifierAttributeCallback::CallbackFn( } CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback:: - CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -35467,8 +35467,8 @@ CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback: } } -CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback:: - ~CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback() +CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback::~ +CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -35588,7 +35588,7 @@ void CHIPDoorLockAliroGroupResolvingKeyAttributeCallback::CallbackFn(void * cont } CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback:: - CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : +CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -35606,8 +35606,8 @@ CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback:: } } -CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback:: - ~CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback() +CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback::~ +CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) From 9003128cfbfee2b9c3fc5d55f79e7f5e48aef2dd Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 16:47:04 -0600 Subject: [PATCH 16/26] zap regen --- .../zap-generated/CHIPInvokeCallbacks.cpp | 64 +- .../java/zap-generated/CHIPReadCallbacks.cpp | 891 +++++++++--------- 2 files changed, 479 insertions(+), 476 deletions(-) diff --git a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp index 21ee0a8e5c300d..0a1171eab1635c 100644 --- a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp @@ -621,7 +621,7 @@ void CHIPGeneralCommissioningClusterArmFailSafeResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText); } CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback:: -CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) : + CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -638,8 +638,8 @@ CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaC } } -CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::~ -CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback() +CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback:: + ~CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -688,7 +688,7 @@ void CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::Callbac env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText); } CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback:: -CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) : + CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -705,8 +705,8 @@ CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject jav } } -CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::~ -CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback() +CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback:: + ~CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -1596,7 +1596,7 @@ void CHIPOperationalCredentialsClusterAttestationResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, AttestationElements, AttestationSignature); } CHIPOperationalCredentialsClusterCertificateChainResponseCallback:: -CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) : + CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -1613,8 +1613,8 @@ CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCa } } -CHIPOperationalCredentialsClusterCertificateChainResponseCallback::~ -CHIPOperationalCredentialsClusterCertificateChainResponseCallback() +CHIPOperationalCredentialsClusterCertificateChainResponseCallback:: + ~CHIPOperationalCredentialsClusterCertificateChainResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -1995,7 +1995,7 @@ void CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, GroupKeySet); } CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback:: -CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) : + CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -2012,8 +2012,8 @@ CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCa } } -CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::~ -CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback() +CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback:: + ~CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -2191,7 +2191,7 @@ void CHIPIcdManagementClusterStayActiveResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, PromisedActiveDuration); } CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback:: -CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback(jobject javaCallback) : + CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -2208,8 +2208,8 @@ CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback(jobject } } -CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback::~ -CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback() +CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback:: + ~CHIPOvenCavityOperationalStateClusterOperationalCommandResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -2455,7 +2455,7 @@ void CHIPLaundryWasherModeClusterChangeToModeResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, Status, StatusText); } CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback(jobject javaCallback) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -2472,8 +2472,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCa } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -2887,8 +2887,8 @@ CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::CHIPRvcOperati } } -CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::~ -CHIPRvcOperationalStateClusterOperationalCommandResponseCallback() +CHIPRvcOperationalStateClusterOperationalCommandResponseCallback:: + ~CHIPRvcOperationalStateClusterOperationalCommandResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6405,7 +6405,7 @@ void CHIPContentAppObserverClusterContentAppMessageResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, Status, Data, EncodingHint); } CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback:: -CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject javaCallback) : + CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -6422,8 +6422,8 @@ CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject ja } } -CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::~ -CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback() +CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback:: + ~CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6500,7 +6500,7 @@ void CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::Call env->CallVoidMethod(javaCallbackRef, javaMethod, profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes); } CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback:: -CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(jobject javaCallback) : + CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -6517,8 +6517,8 @@ CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(job } } -CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback::~ -CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback() +CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback:: + ~CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -7456,7 +7456,7 @@ void CHIPUnitTestingClusterTestNullableOptionalResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, wasPresent, wasNull, value, originalValue); } CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback:: -CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCallback) : + CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -7473,8 +7473,8 @@ CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCa } } -CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback::~ -CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback() +CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback:: + ~CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -8360,7 +8360,7 @@ void CHIPUnitTestingClusterTestEmitTestEventResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, value); } CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback:: -CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject javaCallback) : + CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject javaCallback) : Callback::Callback(CallbackFn, this) { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); @@ -8377,8 +8377,8 @@ CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject java } } -CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback::~ -CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback() +CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback:: + ~CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback() { JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index be1f44d6ab4edf..827f73f4f74a50 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -939,7 +939,7 @@ void CHIPOnOffAttributeListAttributeCallback::CallbackFn(void * context, } CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback:: -CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -957,8 +957,8 @@ CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCa } } -CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback::~ -CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback() +CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback:: + ~CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -1030,8 +1030,8 @@ CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::CHIPOnOffSwitc } } -CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::~ -CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback() +CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback:: + ~CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5071,7 +5071,7 @@ void CHIPBasicInformationAttributeListAttributeCallback::CallbackFn( } CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback:: -CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5089,8 +5089,8 @@ CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaC } } -CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::~ -CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback:: + ~CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5144,7 +5144,7 @@ void CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::Callbac } CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback:: -CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5162,8 +5162,8 @@ CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCa } } -CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback::~ -CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback:: + ~CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5361,7 +5361,7 @@ void CHIPOtaSoftwareUpdateProviderAttributeListAttributeCallback::CallbackFn( } CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback:: -CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5379,8 +5379,8 @@ CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaC } } -CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::~ -CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback() +CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback:: + ~CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5475,7 +5475,7 @@ void CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::Callbac } CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback:: -CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5493,8 +5493,8 @@ CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaC } } -CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::~ -CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback() +CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback:: + ~CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5544,7 +5544,7 @@ void CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::Callbac } CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback:: -CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5562,8 +5562,8 @@ CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject java } } -CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::~ -CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback:: + ~CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5617,7 +5617,7 @@ void CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::Callba } CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback:: -CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5635,8 +5635,8 @@ CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaC } } -CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback::~ -CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback() +CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback:: + ~CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5902,7 +5902,7 @@ void CHIPLocalizationConfigurationSupportedLocalesAttributeCallback::CallbackFn( } CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback:: -CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5920,8 +5920,8 @@ CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaC } } -CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::~ -CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback() +CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback:: + ~CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -5975,7 +5975,7 @@ void CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::Callbac } CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback:: -CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -5993,8 +5993,8 @@ CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCa } } -CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback::~ -CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback() +CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback:: + ~CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6192,7 +6192,7 @@ void CHIPLocalizationConfigurationAttributeListAttributeCallback::CallbackFn( } CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback:: -CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -6210,8 +6210,8 @@ CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCa } } -CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback::~ -CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback() +CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback:: + ~CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -6911,7 +6911,7 @@ void CHIPPowerSourceConfigurationSourcesAttributeCallback::CallbackFn( } CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback:: -CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -6929,8 +6929,8 @@ CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCa } } -CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback::~ -CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback() +CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback:: + ~CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -7002,8 +7002,8 @@ CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::CHIPPowerSourc } } -CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::~ -CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback() +CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback:: + ~CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12104,7 +12104,7 @@ void CHIPThreadNetworkDiagnosticsChannelPage0MaskAttributeCallback::CallbackFn( } CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback:: -CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -12122,8 +12122,8 @@ CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject jav } } -CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::~ -CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback() +CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback:: + ~CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12178,7 +12178,7 @@ void CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::Callb } CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback:: -CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -12196,8 +12196,8 @@ CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCa } } -CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback::~ -CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback() +CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback:: + ~CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12269,8 +12269,8 @@ CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::CHIPThreadNetw } } -CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::~ -CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback() +CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback:: + ~CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -12941,7 +12941,7 @@ void CHIPWiFiNetworkDiagnosticsBeaconRxCountAttributeCallback::CallbackFn(void * } CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback:: -CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -12959,8 +12959,8 @@ CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCa } } -CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::~ -CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback() +CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback:: + ~CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -13010,7 +13010,7 @@ void CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::Callback } CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback:: -CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -13028,8 +13028,8 @@ CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCa } } -CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback::~ -CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback() +CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback:: + ~CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -13843,7 +13843,7 @@ void CHIPEthernetNetworkDiagnosticsCarrierDetectAttributeCallback::CallbackFn(vo } CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback:: -CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -13861,8 +13861,8 @@ CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject java } } -CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::~ -CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback() +CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback:: + ~CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -13916,7 +13916,7 @@ void CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::Callba } CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback:: -CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -13934,8 +13934,8 @@ CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaC } } -CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback::~ -CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback() +CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback:: + ~CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -14851,7 +14851,7 @@ void CHIPTimeSynchronizationAttributeListAttributeCallback::CallbackFn( } CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback:: -CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -14869,8 +14869,8 @@ CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject j } } -CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::~ -CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback() +CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback:: + ~CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -14924,7 +14924,7 @@ void CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::Cal } CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback:: -CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -14942,8 +14942,8 @@ CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject ja } } -CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback::~ -CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback() +CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback:: + ~CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -15559,7 +15559,7 @@ void CHIPAdministratorCommissioningAdminVendorIdAttributeCallback::CallbackFn( } CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback:: -CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -15577,8 +15577,8 @@ CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject java } } -CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::~ -CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback() +CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback:: + ~CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -15632,7 +15632,7 @@ void CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::Callba } CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback:: -CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -15650,8 +15650,8 @@ CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaC } } -CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback::~ -CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback() +CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback:: + ~CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -16090,7 +16090,7 @@ void CHIPOperationalCredentialsFabricsAttributeCallback::CallbackFn( } CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback:: -CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -16108,8 +16108,8 @@ CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaC } } -CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback::~ -CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback() +CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback:: + ~CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -19751,7 +19751,7 @@ void CHIPOvenCavityOperationalStateCountdownTimeAttributeCallback::CallbackFn( } CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback:: -CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -19769,8 +19769,8 @@ CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback(jobject java } } -CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback::~ -CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback() +CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback:: + ~CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -19864,7 +19864,7 @@ void CHIPOvenCavityOperationalStateOperationalStateListAttributeCallback::Callba } CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback:: -CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -19882,8 +19882,8 @@ CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback(jobject java } } -CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback::~ -CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback() +CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback:: + ~CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -19937,7 +19937,7 @@ void CHIPOvenCavityOperationalStateGeneratedCommandListAttributeCallback::Callba } CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback:: -CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -19955,8 +19955,8 @@ CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback(jobject javaC } } -CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback::~ -CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback() +CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback:: + ~CHIPOvenCavityOperationalStateAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22337,7 +22337,7 @@ void CHIPLaundryWasherModeAttributeListAttributeCallback::CallbackFn( } CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22356,8 +22356,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallba } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22502,7 +22502,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeC } CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -22521,8 +22521,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback( } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22573,7 +22573,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCall } CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -22592,8 +22592,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobje } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22644,7 +22644,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback: } CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22663,8 +22663,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttribute } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22721,7 +22721,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttr } CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22740,8 +22740,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeC } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22798,7 +22798,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttri } CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -22817,8 +22817,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jo } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -22873,7 +22873,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallba } CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback:: -CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -22892,8 +22892,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallbac } } -CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback::~ -CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback() +CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback:: + ~CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -24444,7 +24444,7 @@ void CHIPRvcCleanModeAttributeListAttributeCallback::CallbackFn(void * context, } CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback:: -CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -24462,8 +24462,8 @@ CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCa } } -CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback::~ -CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback() +CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback:: + ~CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29467,7 +29467,7 @@ void CHIPHepaFilterMonitoringAttributeListAttributeCallback::CallbackFn( } CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback:: -CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29485,8 +29485,8 @@ CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject java } } -CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::~ -CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback() +CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback:: + ~CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29536,7 +29536,7 @@ void CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::Callba } CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback:: -CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -29555,8 +29555,8 @@ CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobje } } -CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback::~ -CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback:: + ~CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29642,7 +29642,7 @@ void CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback: } CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback:: -CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29660,8 +29660,8 @@ CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject } } -CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::~ -CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback:: + ~CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29715,7 +29715,7 @@ void CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::C } CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback:: -CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29733,8 +29733,8 @@ CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject } } -CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback::~ -CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback:: + ~CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29860,7 +29860,7 @@ void CHIPActivatedCarbonFilterMonitoringEventListAttributeCallback::CallbackFn( } CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback:: -CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29878,8 +29878,8 @@ CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCa } } -CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::~ -CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback() +CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback:: + ~CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -29933,7 +29933,7 @@ void CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::Callback } CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback:: -CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -29951,8 +29951,8 @@ CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback(jobject javaC } } -CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback::~ -CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback() +CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback:: + ~CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30006,7 +30006,7 @@ void CHIPBooleanStateConfigurationGeneratedCommandListAttributeCallback::Callbac } CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback:: -CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30024,8 +30024,8 @@ CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback(jobject javaCa } } -CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback::~ -CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback() +CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback:: + ~CHIPBooleanStateConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30291,7 +30291,7 @@ void CHIPValveConfigurationAndControlOpenDurationAttributeCallback::CallbackFn( } CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback:: -CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30309,8 +30309,8 @@ CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback(jobject jav } } -CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback::~ -CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback() +CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback:: + ~CHIPValveConfigurationAndControlDefaultOpenDurationAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30428,7 +30428,7 @@ void CHIPValveConfigurationAndControlAutoCloseTimeAttributeCallback::CallbackFn( } CHIPValveConfigurationAndControlRemainingDurationAttributeCallback:: -CHIPValveConfigurationAndControlRemainingDurationAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPValveConfigurationAndControlRemainingDurationAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30446,8 +30446,8 @@ CHIPValveConfigurationAndControlRemainingDurationAttributeCallback(jobject javaC } } -CHIPValveConfigurationAndControlRemainingDurationAttributeCallback::~ -CHIPValveConfigurationAndControlRemainingDurationAttributeCallback() +CHIPValveConfigurationAndControlRemainingDurationAttributeCallback:: + ~CHIPValveConfigurationAndControlRemainingDurationAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30769,7 +30769,7 @@ void CHIPValveConfigurationAndControlTargetLevelAttributeCallback::CallbackFn( } CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback:: -CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30787,8 +30787,8 @@ CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback(jobject ja } } -CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback::~ -CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback() +CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback:: + ~CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -30842,7 +30842,7 @@ void CHIPValveConfigurationAndControlGeneratedCommandListAttributeCallback::Call } CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback:: -CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -30860,8 +30860,8 @@ CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback(jobject jav } } -CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback::~ -CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback() +CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback:: + ~CHIPValveConfigurationAndControlAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -31059,7 +31059,7 @@ void CHIPValveConfigurationAndControlAttributeListAttributeCallback::CallbackFn( } CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback:: -CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -31077,8 +31077,8 @@ CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback(jobject jav } } -CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback::~ -CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback() +CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -31132,7 +31132,7 @@ void CHIPElectricalEnergyMeasurementGeneratedCommandListAttributeCallback::Callb } CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback:: -CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -31150,8 +31150,8 @@ CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback(jobject java } } -CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback::~ -CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback() +CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPElectricalEnergyMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -31349,7 +31349,7 @@ void CHIPElectricalEnergyMeasurementAttributeListAttributeCallback::CallbackFn( } CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback:: -CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -31367,8 +31367,8 @@ CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback(jobject javaCa } } -CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback::~ -CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback() +CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback:: + ~CHIPDemandResponseLoadControlLoadControlProgramsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -32625,7 +32625,7 @@ void CHIPDemandResponseLoadControlActiveEventsAttributeCallback::CallbackFn( } CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback:: -CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -32643,8 +32643,8 @@ CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback(jobject javaC } } -CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback::~ -CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback() +CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback:: + ~CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -32698,7 +32698,7 @@ void CHIPDemandResponseLoadControlGeneratedCommandListAttributeCallback::Callbac } CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback:: -CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -32716,8 +32716,8 @@ CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback(jobject javaCa } } -CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback::~ -CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback() +CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback:: + ~CHIPDemandResponseLoadControlAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -32915,7 +32915,7 @@ void CHIPDemandResponseLoadControlAttributeListAttributeCallback::CallbackFn( } CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback:: -CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -32933,8 +32933,8 @@ CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback(jobject jav } } -CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback::~ -CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback() +CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback:: + ~CHIPDeviceEnergyManagementPowerAdjustmentCapabilityAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -35448,7 +35448,7 @@ void CHIPDoorLockAliroReaderGroupIdentifierAttributeCallback::CallbackFn( } CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback:: -CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -35467,8 +35467,8 @@ CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback( } } -CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback::~ -CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback() +CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback:: + ~CHIPDoorLockAliroExpeditedTransactionSupportedProtocolVersionsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -35588,7 +35588,7 @@ void CHIPDoorLockAliroGroupResolvingKeyAttributeCallback::CallbackFn(void * cont } CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback:: -CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -35606,8 +35606,8 @@ CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback(jobject javaCa } } -CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback::~ -CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback() +CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback:: + ~CHIPDoorLockAliroSupportedBLEUWBProtocolVersionsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36096,8 +36096,8 @@ CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::CHIPWindowCove } } -CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::~ -CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback() +CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback:: + ~CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36165,8 +36165,8 @@ CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::CHIPWindowCove } } -CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::~ -CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback() +CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback:: + ~CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36216,7 +36216,7 @@ void CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::CallbackF } CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback:: -CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36234,8 +36234,8 @@ CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaC } } -CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::~ -CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback() +CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback:: + ~CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36285,7 +36285,7 @@ void CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::Callbac } CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback:: -CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36303,8 +36303,8 @@ CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaC } } -CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::~ -CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback() +CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback:: + ~CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36354,7 +36354,7 @@ void CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::Callbac } CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback:: -CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36372,8 +36372,8 @@ CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject java } } -CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::~ -CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback() +CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback:: + ~CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -36423,7 +36423,7 @@ void CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::Callba } CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback:: -CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -36441,8 +36441,8 @@ CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject java } } -CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback::~ -CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback() +CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback:: + ~CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -37284,8 +37284,8 @@ CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::CHIPPumpConfig } } -CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::~ -CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback() +CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback:: + ~CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -37353,8 +37353,8 @@ CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::CHIPPumpConfig } } -CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::~ -CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback() +CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback:: + ~CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38084,7 +38084,7 @@ void CHIPPumpConfigurationAndControlSpeedAttributeCallback::CallbackFn(void * co } CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback:: -CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38102,8 +38102,8 @@ CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject jav } } -CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback::~ -CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback() +CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback:: + ~CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38221,7 +38221,7 @@ void CHIPPumpConfigurationAndControlPowerAttributeCallback::CallbackFn(void * co } CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback:: -CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38239,8 +38239,8 @@ CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject j } } -CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::~ -CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback() +CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback:: + ~CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38290,7 +38290,7 @@ void CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::Cal } CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback:: -CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38308,8 +38308,8 @@ CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject jav } } -CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::~ -CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback() +CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback:: + ~CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -38363,7 +38363,7 @@ void CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::Callb } CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback:: -CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -38381,8 +38381,8 @@ CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject java } } -CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback::~ -CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback() +CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback:: + ~CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -40959,7 +40959,7 @@ void CHIPFanControlAttributeListAttributeCallback::CallbackFn(void * context, } CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback:: -CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -40978,8 +40978,8 @@ CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jo } } -CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback::~ -CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback:: + ~CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41034,7 +41034,7 @@ void CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallba } CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback:: -CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -41053,8 +41053,8 @@ CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(job } } -CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback::~ -CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback:: + ~CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41109,7 +41109,7 @@ void CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallbac } CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback:: -CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -41127,8 +41127,8 @@ CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaC } } -CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::~ -CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback:: + ~CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -41182,7 +41182,7 @@ void CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::Callbac } CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback:: -CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -41200,8 +41200,8 @@ CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject j } } -CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::~ -CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback() +CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback:: + ~CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -42367,8 +42367,8 @@ CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::CHIPBallastCon } } -CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::~ -CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback() +CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback:: + ~CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45229,8 +45229,8 @@ CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::CHIPRelativeHu } } -CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::~ -CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback() +CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45298,8 +45298,8 @@ CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::CHIPRelativeHu } } -CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback() +CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45349,7 +45349,7 @@ void CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::CallbackF } CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback:: -CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -45367,8 +45367,8 @@ CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject jav } } -CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::~ -CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback() +CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45422,7 +45422,7 @@ void CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::Callb } CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback:: -CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -45440,8 +45440,8 @@ CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject java } } -CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback::~ -CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback() +CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45925,7 +45925,7 @@ void CHIPOccupancySensingAttributeListAttributeCallback::CallbackFn( } CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -45943,8 +45943,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject } } -CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -45994,7 +45994,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::C } CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46013,8 +46013,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobj } } -CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46065,7 +46065,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback } CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46084,8 +46084,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobj } } -CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46136,7 +46136,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback } CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46155,8 +46155,8 @@ CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(job } } -CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46207,7 +46207,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallbac } CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46226,8 +46226,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback( } } -CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46278,7 +46278,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCall } CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46297,8 +46297,8 @@ CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback( } } -CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46353,7 +46353,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCall } CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46372,8 +46372,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(j } } -CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46428,7 +46428,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallb } CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -46446,8 +46446,8 @@ CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject jav } } -CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46501,7 +46501,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::Callb } CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback:: -CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -46519,8 +46519,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject } } -CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::~ -CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback() +CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback:: + ~CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46574,7 +46574,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::C } CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -46592,8 +46592,8 @@ CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject } } -CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46643,7 +46643,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::Ca } CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46662,8 +46662,8 @@ CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobje } } -CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46714,7 +46714,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback: } CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46733,8 +46733,8 @@ CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobje } } -CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46785,7 +46785,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback: } CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46804,8 +46804,8 @@ CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobj } } -CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46856,7 +46856,7 @@ void CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback } CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46875,8 +46875,8 @@ CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(j } } -CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -46927,7 +46927,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallb } CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -46946,8 +46946,8 @@ CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(j } } -CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47002,7 +47002,7 @@ void CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallb } CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47021,8 +47021,8 @@ CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jo } } -CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47077,7 +47077,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallba } CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47095,8 +47095,8 @@ CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject java } } -CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47150,7 +47150,7 @@ void CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::Callba } CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback:: -CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47168,8 +47168,8 @@ CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject } } -CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::~ -CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback() +CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback:: + ~CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47223,7 +47223,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::Ca } CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47242,8 +47242,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobjec } } -CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47293,7 +47293,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback:: } CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47312,8 +47312,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(job } } -CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47364,7 +47364,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallbac } CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47383,8 +47383,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(job } } -CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47435,7 +47435,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallbac } CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47454,8 +47454,8 @@ CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jo } } -CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47506,7 +47506,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallba } CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -47525,8 +47525,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback } } -CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47577,7 +47577,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCal } CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -47596,8 +47596,8 @@ CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback } } -CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47652,7 +47652,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCal } CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47671,8 +47671,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback( } } -CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47727,7 +47727,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCall } CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47745,8 +47745,8 @@ CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject ja } } -CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47800,7 +47800,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::Call } CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback:: -CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -47819,8 +47819,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobjec } } -CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback::~ -CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback() +CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback:: + ~CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -47942,7 +47942,7 @@ void CHIPOzoneConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn } CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -47960,8 +47960,8 @@ CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaC } } -CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48011,7 +48011,7 @@ void CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::Callbac } CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48029,8 +48029,8 @@ CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaC } } -CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48080,7 +48080,7 @@ void CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callbac } CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48098,8 +48098,8 @@ CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject java } } -CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48149,7 +48149,7 @@ void CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callba } CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48167,8 +48167,8 @@ CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject j } } -CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48218,7 +48218,7 @@ void CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::Cal } CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48236,8 +48236,8 @@ CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject j } } -CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48291,7 +48291,7 @@ void CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::Cal } CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48309,8 +48309,8 @@ CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject ja } } -CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48576,7 +48576,7 @@ void CHIPPm25ConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn( } CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48594,8 +48594,8 @@ CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCa } } -CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48645,7 +48645,7 @@ void CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::Callback } CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48663,8 +48663,8 @@ CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCa } } -CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48714,7 +48714,7 @@ void CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callback } CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48732,8 +48732,8 @@ CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaC } } -CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48783,7 +48783,7 @@ void CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callbac } CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48801,8 +48801,8 @@ CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject ja } } -CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48852,7 +48852,7 @@ void CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Call } CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48870,8 +48870,8 @@ CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject ja } } -CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -48925,7 +48925,7 @@ void CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::Call } CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -48943,8 +48943,8 @@ CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject jav } } -CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49142,7 +49142,7 @@ void CHIPPm25ConcentrationMeasurementAttributeListAttributeCallback::CallbackFn( } CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49160,8 +49160,8 @@ CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject j } } -CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49211,7 +49211,7 @@ void CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::Cal } CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49230,8 +49230,8 @@ CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobjec } } -CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49281,7 +49281,7 @@ void CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback:: } CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49300,8 +49300,8 @@ CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobjec } } -CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49351,7 +49351,7 @@ void CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback:: } CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49370,8 +49370,8 @@ CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobje } } -CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49422,7 +49422,7 @@ void CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback: } CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49441,8 +49441,8 @@ CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jo } } -CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49493,7 +49493,7 @@ void CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallba } CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49512,8 +49512,8 @@ CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jo } } -CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49568,7 +49568,7 @@ void CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallba } CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -49587,8 +49587,8 @@ CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(job } } -CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49643,7 +49643,7 @@ void CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallbac } CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49661,8 +49661,8 @@ CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaC } } -CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49716,7 +49716,7 @@ void CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::Callbac } CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback:: -CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -49734,8 +49734,8 @@ CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject j } } -CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback::~ -CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback() +CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback:: + ~CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49875,8 +49875,8 @@ CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::CHIPPm1Concent } } -CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49944,8 +49944,8 @@ CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::CHIPPm1Concent } } -CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -49995,7 +49995,7 @@ void CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::CallbackF } CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50013,8 +50013,8 @@ CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCa } } -CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50064,7 +50064,7 @@ void CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callback } CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50082,8 +50082,8 @@ CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject jav } } -CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50133,7 +50133,7 @@ void CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Callb } CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50151,8 +50151,8 @@ CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject jav } } -CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50206,7 +50206,7 @@ void CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::Callb } CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50224,8 +50224,8 @@ CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject java } } -CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50491,7 +50491,7 @@ void CHIPPm10ConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn( } CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50509,8 +50509,8 @@ CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCa } } -CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50560,7 +50560,7 @@ void CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::Callback } CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50578,8 +50578,8 @@ CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCa } } -CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50629,7 +50629,7 @@ void CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callback } CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50647,8 +50647,8 @@ CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaC } } -CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50698,7 +50698,7 @@ void CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callbac } CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50716,8 +50716,8 @@ CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject ja } } -CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50767,7 +50767,7 @@ void CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Call } CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50785,8 +50785,8 @@ CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject ja } } -CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -50840,7 +50840,7 @@ void CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::Call } CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -50858,8 +50858,8 @@ CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject jav } } -CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51057,7 +51057,7 @@ void CHIPPm10ConcentrationMeasurementAttributeListAttributeCallback::CallbackFn( } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51076,8 +51076,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeC } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51130,7 +51130,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttri } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51149,8 +51150,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttribu } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51203,7 +51204,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAt } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51222,8 +51224,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttribu } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51276,7 +51278,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAt } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive) @@ -51295,8 +51298,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttrib } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51349,8 +51352,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueA } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, - bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this), @@ -51370,8 +51373,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAtt } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51425,8 +51428,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredVal } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, - bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), @@ -51446,8 +51449,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAtt } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51505,8 +51508,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandLi } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, - bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, + bool keepAlive) : chip::Callback::Callback< CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive) @@ -51525,8 +51528,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttr } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51584,7 +51587,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandLis } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51603,8 +51606,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallb } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51660,7 +51663,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttribute } CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback:: -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback( CallbackFn, this), keepAlive(keepAlive) @@ -51679,8 +51682,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeC } } -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback::~ -CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback() +CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback:: + ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51805,7 +51808,7 @@ void CHIPRadonConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn } CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback:: -CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51823,8 +51826,8 @@ CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaC } } -CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::~ -CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback:: + ~CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51874,7 +51877,7 @@ void CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::Callbac } CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback:: -CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51892,8 +51895,8 @@ CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaC } } -CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::~ -CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback:: + ~CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -51943,7 +51946,7 @@ void CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callbac } CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback:: -CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -51961,8 +51964,8 @@ CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject java } } -CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::~ -CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback:: + ~CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52012,7 +52015,7 @@ void CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callba } CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback:: -CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52030,8 +52033,8 @@ CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject j } } -CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::~ -CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback() +CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback:: + ~CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52081,7 +52084,7 @@ void CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::Cal } CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback:: -CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52099,8 +52102,8 @@ CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject j } } -CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::~ -CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback() +CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback:: + ~CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) @@ -52154,7 +52157,7 @@ void CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::Cal } CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback:: -CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : + CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -52172,8 +52175,8 @@ CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject ja } } -CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback::~ -CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback() +CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback:: + ~CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback() { JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); if (env == nullptr) From 172657e656a5540ff7fa066f4bd76e2f953aba49 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 23:47:25 -0600 Subject: [PATCH 17/26] Cleanup --- .../data_model/controller-clusters.zap | 229 +++++++++++++++++- 1 file changed, 222 insertions(+), 7 deletions(-) diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index e07793b550531d..9c1c09406ad207 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -17,6 +17,12 @@ } ], "package": [ + { + "pathRelativity": "relativeToZap", + "path": "../../app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" + }, { "pathRelativity": "relativeToZap", "path": "../../app/zap-templates/zcl/zcl.json", @@ -24,12 +30,6 @@ "category": "matter", "version": 1, "description": "Matter SDK ZCL data" - }, - { - "pathRelativity": "relativeToZap", - "path": "../../app/zap-templates/app-templates.json", - "type": "gen-templates-json", - "version": "chip-v1" } ], "endpointTypes": [ @@ -1948,6 +1948,75 @@ "source": "client", "isIncoming": 0, "isEnabled": 1 + }, + { + "name": "StayActiveResponse", + "code": 4, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Timer", + "code": 71, + "mfgCode": null, + "define": "TIMER_CLUSTER", + "side": "client", + "enabled": 1, + "apiMaturity": "provisional", + "commands": [ + { + "name": "SetTimer", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "AddTime", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 } ], "attributes": [ @@ -2062,7 +2131,49 @@ "side": "client", "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Laundry Dryer Controls", + "code": 74, + "mfgCode": null, + "define": "LAUNDRY_DRYER_CONTROLS_CLUSTER", + "side": "client", + "enabled": 1, + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", "singleton": 0, "bounded": 0, "defaultValue": "0", @@ -3013,6 +3124,110 @@ } ] }, + { + "name": "Device Energy Management", + "code": 152, + "mfgCode": null, + "define": "DEVICE_ENERGY_MANAGEMENT_CLUSTER", + "side": "client", + "enabled": 1, + "apiMaturity": "provisional", + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Energy EVSE", + "code": 153, + "mfgCode": null, + "define": "ENERGY_EVSE_CLUSTER", + "side": "client", + "enabled": 1, + "apiMaturity": "provisional", + "commands": [ + { + "name": "Disable", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "EnableCharging", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, { "name": "Door Lock", "code": 257, From d0e1e834f6a0a375e010d79d9d6d9077ce525288 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 9 Jan 2024 23:50:44 -0600 Subject: [PATCH 18/26] revert unimportant changes --- src/controller/data_model/controller-clusters.zap | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 9c1c09406ad207..b5e11ab3218e84 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -17,12 +17,6 @@ } ], "package": [ - { - "pathRelativity": "relativeToZap", - "path": "../../app/zap-templates/app-templates.json", - "type": "gen-templates-json", - "version": "chip-v1" - }, { "pathRelativity": "relativeToZap", "path": "../../app/zap-templates/zcl/zcl.json", @@ -30,6 +24,12 @@ "category": "matter", "version": 1, "description": "Matter SDK ZCL data" + }, + { + "pathRelativity": "relativeToZap", + "path": "../../app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" } ], "endpointTypes": [ From 00ddeddf437682b809acdfa71925d2c3a254cb7e Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Fri, 12 Jan 2024 17:34:00 -0600 Subject: [PATCH 19/26] regen zap --- .../data_model/controller-clusters.zap | 12 +++++----- .../app-common/zap-generated/callback.h | 24 ------------------- 2 files changed, 6 insertions(+), 30 deletions(-) diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index b5e11ab3218e84..9c1c09406ad207 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -17,6 +17,12 @@ } ], "package": [ + { + "pathRelativity": "relativeToZap", + "path": "../../app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" + }, { "pathRelativity": "relativeToZap", "path": "../../app/zap-templates/zcl/zcl.json", @@ -24,12 +30,6 @@ "category": "matter", "version": 1, "description": "Matter SDK ZCL data" - }, - { - "pathRelativity": "relativeToZap", - "path": "../../app/zap-templates/app-templates.json", - "type": "gen-templates-json", - "version": "chip-v1" } ], "endpointTypes": [ 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 33f6cfaa4a01f5..e6313f4fbd04a4 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -5428,30 +5428,6 @@ bool emberAfTimerClusterAddTimeCallback(chip::app::CommandHandler * commandObj, bool emberAfTimerClusterReduceTimeCallback(chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::Timer::Commands::ReduceTime::DecodableType & commandData); -/** - * @brief Oven Cavity Operational State Cluster Pause Command callback (from client) - */ -bool emberAfOvenCavityOperationalStateClusterPauseCallback( - chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, - const chip::app::Clusters::OvenCavityOperationalState::Commands::Pause::DecodableType & commandData); -/** - * @brief Oven Cavity Operational State Cluster Stop Command callback (from client) - */ -bool emberAfOvenCavityOperationalStateClusterStopCallback( - chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, - const chip::app::Clusters::OvenCavityOperationalState::Commands::Stop::DecodableType & commandData); -/** - * @brief Oven Cavity Operational State Cluster Start Command callback (from client) - */ -bool emberAfOvenCavityOperationalStateClusterStartCallback( - chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, - const chip::app::Clusters::OvenCavityOperationalState::Commands::Start::DecodableType & commandData); -/** - * @brief Oven Cavity Operational State Cluster Resume Command callback (from client) - */ -bool emberAfOvenCavityOperationalStateClusterResumeCallback( - chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, - const chip::app::Clusters::OvenCavityOperationalState::Commands::Resume::DecodableType & commandData); /** * @brief Mode Select Cluster ChangeToMode Command callback (from client) */ From 082b829c42896d2ba8454c1f105ef1fb0b1e4101 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 16 Jan 2024 14:10:30 -0600 Subject: [PATCH 20/26] restore third_party to master --- third_party/imgui/repo | 2 +- third_party/libwebsockets/repo | 2 +- third_party/mbedtls/repo | 2 +- third_party/nanopb/repo | 2 +- third_party/openthread/repo | 2 +- third_party/ot-br-posix/repo | 2 +- third_party/pigweed/repo | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/third_party/imgui/repo b/third_party/imgui/repo index 240ab5890b2e8d..6228c2e1ec7ef2 160000 --- a/third_party/imgui/repo +++ b/third_party/imgui/repo @@ -1 +1 @@ -Subproject commit 240ab5890b2e8da294937a1710b021ac3f271472 +Subproject commit 6228c2e1ec7ef21ca1809579c055ed34540dedb0 diff --git a/third_party/libwebsockets/repo b/third_party/libwebsockets/repo index f18fc2316f9743..49bfef2ecd51b8 160000 --- a/third_party/libwebsockets/repo +++ b/third_party/libwebsockets/repo @@ -1 +1 @@ -Subproject commit f18fc2316f9743624ced9ba934595f7b9ba8cd05 +Subproject commit 49bfef2ecd51b854b63e35d913849b6bb518a7f6 diff --git a/third_party/mbedtls/repo b/third_party/mbedtls/repo index ffb18d2012909c..56fd26cee97531 160000 --- a/third_party/mbedtls/repo +++ b/third_party/mbedtls/repo @@ -1 +1 @@ -Subproject commit ffb18d2012909c05277a1e16dc6ba23dc8ba2854 +Subproject commit 56fd26cee97531f223071b91ed108dc1e22e7a85 diff --git a/third_party/nanopb/repo b/third_party/nanopb/repo index cf26d28b88010d..423c03b626a861 160000 --- a/third_party/nanopb/repo +++ b/third_party/nanopb/repo @@ -1 +1 @@ -Subproject commit cf26d28b88010dd3ac94e0cba64d4a71522154bc +Subproject commit 423c03b626a861a7b3a08a2d411e23aefd58827b diff --git a/third_party/openthread/repo b/third_party/openthread/repo index d81c6fab98df8f..f1e74a036b5bd2 160000 --- a/third_party/openthread/repo +++ b/third_party/openthread/repo @@ -1 +1 @@ -Subproject commit d81c6fab98df8fbeb0f3611ce5ec4c131c84cbce +Subproject commit f1e74a036b5bd2e9dd6565161ab806cc854dc0b4 diff --git a/third_party/ot-br-posix/repo b/third_party/ot-br-posix/repo index 657e775cd9ca75..58822dce193456 160000 --- a/third_party/ot-br-posix/repo +++ b/third_party/ot-br-posix/repo @@ -1 +1 @@ -Subproject commit 657e775cd9ca757af7487da2fb039aee645c3d65 +Subproject commit 58822dce1934568523bf1389c039f249e1d979ad diff --git a/third_party/pigweed/repo b/third_party/pigweed/repo index cbbc73dc4d56bc..9640cdef100f87 160000 --- a/third_party/pigweed/repo +++ b/third_party/pigweed/repo @@ -1 +1 @@ -Subproject commit cbbc73dc4d56bc201e9d50c4b10db974aff82754 +Subproject commit 9640cdef100f87d7987875d3a418931d6500e5b2 From b4d4509636cc7f0ad23b90d29dbda2f65a13d8bb Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 16 Jan 2024 14:15:22 -0600 Subject: [PATCH 21/26] revert settings change --- .vscode/settings.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 905aa90a8427e7..bfac435030bb4f 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -127,7 +127,7 @@ "**/third_party/**": true }, "files.eol": "\n", - "editor.formatOnSave": false, + "editor.formatOnSave": true, "better-comments.tags": [ { "tag": "!", From aab91e4d9e9ae10db7e3196557d3373912c1756c Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Tue, 16 Jan 2024 23:01:20 -0600 Subject: [PATCH 22/26] reverting whitespace changes. --- .../esp32/main/CMakeLists.txt | 258 +++++++++--------- 1 file changed, 131 insertions(+), 127 deletions(-) diff --git a/examples/all-clusters-app/esp32/main/CMakeLists.txt b/examples/all-clusters-app/esp32/main/CMakeLists.txt index 896f714bcf973b..623e2ded547abe 100644 --- a/examples/all-clusters-app/esp32/main/CMakeLists.txt +++ b/examples/all-clusters-app/esp32/main/CMakeLists.txt @@ -1,28 +1,28 @@ # -# Copyright (c) 2021 Project CHIP Authors -# All rights reserved. +# Copyright (c) 2021 Project CHIP Authors +# All rights reserved. # -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at +# 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 +# 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. +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. # # (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) # The list of src and include dirs must be in sync with that in all-clusters-app/esp32/main/component.mk set(PRIV_INCLUDE_DIRS_LIST - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/include" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/energy-management-app/energy-management-common/include" - "${CMAKE_CURRENT_LIST_DIR}/include" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/providers" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/third_party/nlfaultinjection/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/energy-management-app/energy-management-common/include" + "${CMAKE_CURRENT_LIST_DIR}/include" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/providers" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/third_party/nlfaultinjection/include" ) set(SRC_DIRS_LIST "${CMAKE_CURRENT_LIST_DIR}" @@ -96,50 +96,51 @@ set(SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/electrical-energy-measurement-server" ) + set(EXCLUDE_SRCS "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp") -if(CONFIG_ENABLE_PW_RPC) - # Append additional directories for RPC build - set(PRIV_INCLUDE_DIRS_LIST "${PRIV_INCLUDE_DIRS_LIST}" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/pw_sys_io/public" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/lib/support" - ) +if (CONFIG_ENABLE_PW_RPC) +# Append additional directories for RPC build +set(PRIV_INCLUDE_DIRS_LIST "${PRIV_INCLUDE_DIRS_LIST}" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/pw_sys_io/public" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/lib/support" +) - if(${IDF_VERSION_MAJOR} LESS 5) +if (${IDF_VERSION_MAJOR} LESS 5) list(APPEND PRIV_INCLUDE_DIRS_LIST "${IDF_PATH}/components/freertos/include/freertos") - else() +else() list(APPEND PRIV_INCLUDE_DIRS_LIST "${IDF_PATH}/components/freertos/FreeRTOS-Kernel/include/freertos") - endif() +endif() - set(SRC_DIRS_LIST "${SRC_DIRS_LIST}" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" - "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" - ) -endif(CONFIG_ENABLE_PW_RPC) +set(SRC_DIRS_LIST "${SRC_DIRS_LIST}" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/common/pigweed/esp32" +) +endif (CONFIG_ENABLE_PW_RPC) -if(CONFIG_ENABLE_ICD_SERVER) - list(APPEND PRIV_INCLUDE_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") - list(APPEND SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") +if (CONFIG_ENABLE_ICD_SERVER) + list(APPEND PRIV_INCLUDE_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") + list(APPEND SRC_DIRS_LIST "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/platform/esp32/icd") endif() set(PRIV_REQUIRES_LIST chip QRCode bt app_update nvs_flash spi_flash openthread) if(${IDF_TARGET} STREQUAL "esp32") - list(APPEND PRIV_REQUIRES_LIST spidriver screen-framework) + list(APPEND PRIV_REQUIRES_LIST spidriver screen-framework) endif() if(CONFIG_DEVICE_TYPE_ESP32_C3_DEVKITM) - list(APPEND PRIV_REQUIRES_LIST led_strip) + list(APPEND PRIV_REQUIRES_LIST led_strip) endif() idf_component_register(PRIV_INCLUDE_DIRS ${PRIV_INCLUDE_DIRS_LIST} - SRC_DIRS ${SRC_DIRS_LIST} - EXCLUDE_SRCS ${EXCLUDE_SRCS} - PRIV_REQUIRES ${PRIV_REQUIRES_LIST}) + SRC_DIRS ${SRC_DIRS_LIST} + EXCLUDE_SRCS ${EXCLUDE_SRCS} + PRIV_REQUIRES ${PRIV_REQUIRES_LIST}) get_filename_component(CHIP_ROOT ${CMAKE_SOURCE_DIR}/third_party/connectedhomeip REALPATH) @@ -151,132 +152,135 @@ chip_app_component_zapgen("${CHIP_ROOT}/examples/all-clusters-app/all-clusters-c set_property(TARGET ${COMPONENT_LIB} PROPERTY CXX_STANDARD 17) target_compile_options(${COMPONENT_LIB} PRIVATE "-DCHIP_HAVE_CONFIG_H") target_compile_options(${COMPONENT_LIB} PUBLIC - "-DCHIP_ADDRESS_RESOLVE_IMPL_INCLUDE_HEADER=" + "-DCHIP_ADDRESS_RESOLVE_IMPL_INCLUDE_HEADER=" ) -if(CONFIG_ENABLE_PW_RPC) - set(PIGWEED_ROOT "${CHIP_ROOT}/third_party/pigweed/repo") - include(${PIGWEED_ROOT}/pw_build/pigweed.cmake) - include(${PIGWEED_ROOT}/pw_protobuf_compiler/proto.cmake) - set(dir_pw_third_party_nanopb "${CHIP_ROOT}/third_party/nanopb/repo" CACHE STRING "" FORCE) +if (CONFIG_ENABLE_PW_RPC) - pw_proto_library(attributes_service - SOURCES + +set(PIGWEED_ROOT "${CHIP_ROOT}/third_party/pigweed/repo") +include(${PIGWEED_ROOT}/pw_build/pigweed.cmake) +include(${PIGWEED_ROOT}/pw_protobuf_compiler/proto.cmake) +set(dir_pw_third_party_nanopb "${CHIP_ROOT}/third_party/nanopb/repo" CACHE STRING "" FORCE) + +pw_proto_library(attributes_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/attributes_service.proto - INPUTS + INPUTS ${CHIP_ROOT}/examples/common/pigweed/protos/attributes_service.options - PREFIX + PREFIX attributes_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto - ) +) - pw_proto_library(button_service - SOURCES +pw_proto_library(button_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/button_service.proto - PREFIX + PREFIX button_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto - ) +) - pw_proto_library(descriptor_service - SOURCES +pw_proto_library(descriptor_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/descriptor_service.proto - PREFIX + PREFIX descriptor_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto - ) +) - pw_proto_library(device_service - SOURCES +pw_proto_library(device_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/device_service.proto - INPUTS + INPUTS ${CHIP_ROOT}/examples/common/pigweed/protos/device_service.options - PREFIX + PREFIX device_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto - ) +) - pw_proto_library(lighting_service - SOURCES +pw_proto_library(lighting_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/lighting_service.proto - PREFIX + PREFIX lighting_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto - ) +) - pw_proto_library(locking_service - SOURCES +pw_proto_library(locking_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/locking_service.proto - PREFIX + PREFIX locking_service - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - DEPS + DEPS pw_protobuf.common_proto - ) +) - pw_proto_library(wifi_service - SOURCES +pw_proto_library(wifi_service + SOURCES ${CHIP_ROOT}/examples/common/pigweed/protos/wifi_service.proto - INPUTS + INPUTS ${CHIP_ROOT}/examples/common/pigweed/protos/wifi_service.options - PREFIX + PREFIX wifi_service - DEPS + DEPS pw_protobuf.common_proto - STRIP_PREFIX + STRIP_PREFIX ${CHIP_ROOT}/examples/common/pigweed/protos - ) +) - target_link_libraries(${COMPONENT_LIB} PUBLIC - attributes_service.nanopb_rpc - button_service.nanopb_rpc - descriptor_service.nanopb_rpc - device_service.nanopb_rpc - lighting_service.nanopb_rpc - locking_service.nanopb_rpc - wifi_service.nanopb_rpc - pw_checksum - pw_hdlc - pw_log - pw_rpc.server - pw_sys_io - pw_trace - pw_trace_tokenized - pw_trace_tokenized.trace_buffer - pw_trace_tokenized.rpc_service - pw_trace_tokenized.protos.nanopb_rpc - ) +target_link_libraries(${COMPONENT_LIB} PUBLIC + attributes_service.nanopb_rpc + button_service.nanopb_rpc + descriptor_service.nanopb_rpc + device_service.nanopb_rpc + lighting_service.nanopb_rpc + locking_service.nanopb_rpc + wifi_service.nanopb_rpc + pw_checksum + pw_hdlc + pw_log + pw_rpc.server + pw_sys_io + pw_trace + pw_trace_tokenized + pw_trace_tokenized.trace_buffer + pw_trace_tokenized.rpc_service + pw_trace_tokenized.protos.nanopb_rpc +) - target_link_options(${COMPONENT_LIB} - PUBLIC +target_link_options(${COMPONENT_LIB} + PUBLIC "-T${PIGWEED_ROOT}/pw_tokenizer/pw_tokenizer_linker_sections.ld" "-L${PIGWEED_ROOT}/pw_tokenizer" - ) +) + +target_compile_options(${COMPONENT_LIB} PRIVATE + "-DPW_RPC_ATTRIBUTE_SERVICE=1" + "-DPW_RPC_BUTTON_SERVICE=1" + "-DPW_RPC_DESCRIPTOR_SERVICE=1" + "-DPW_RPC_DEVICE_SERVICE=1" + "-DPW_RPC_LIGHTING_SERVICE=1" + "-DPW_RPC_LOCKING_SERVICE=1" + "-DPW_RPC_TRACING_SERVICE=1" + "-DPW_RPC_WIFI_SERVICE=1" + "-DPW_TRACE_BACKEND_SET=1") - target_compile_options(${COMPONENT_LIB} PRIVATE - "-DPW_RPC_ATTRIBUTE_SERVICE=1" - "-DPW_RPC_BUTTON_SERVICE=1" - "-DPW_RPC_DESCRIPTOR_SERVICE=1" - "-DPW_RPC_DEVICE_SERVICE=1" - "-DPW_RPC_LIGHTING_SERVICE=1" - "-DPW_RPC_LOCKING_SERVICE=1" - "-DPW_RPC_TRACING_SERVICE=1" - "-DPW_RPC_WIFI_SERVICE=1" - "-DPW_TRACE_BACKEND_SET=1") -endif(CONFIG_ENABLE_PW_RPC) +endif (CONFIG_ENABLE_PW_RPC) From efd8c08af6fa463a56a4b86c6976bbd76c1074f0 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Wed, 17 Jan 2024 09:46:35 -0600 Subject: [PATCH 23/26] regen zap --- .../all-clusters-app.matter | 7 - .../all-clusters-common/all-clusters-app.zap | 4040 ++++++++--------- .../light-switch-app/qpg/zap/switch.matter | 194 - .../qpg/zap/thermostaticRadiatorValve.matter | 122 +- .../data_model/controller-clusters.zap | 270 +- 5 files changed, 2240 insertions(+), 2393 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index 2ac64212c6d7b3..abb2f07a84e93f 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -8114,13 +8114,6 @@ endpoint 1 { ram attribute clusterRevision default = 6; handle command SetpointRaiseLower; - handle command SetActiveScheduleRequest; - handle command SetActivePresetRequest; - handle command StartPresetsSchedulesEditRequest; - handle command CancelPresetsSchedulesEditRequest; - handle command CommitPresetsSchedulesRequest; - handle command CancelSetActivePresetRequest; - handle command SetTemperatureSetpointHoldPolicy; } server cluster FanControl { diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap index 2a661532d30dc8..df67a9000b9d85 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap @@ -17,6 +17,12 @@ } ], "package": [ + { + "pathRelativity": "relativeToZap", + "path": "../../../src/app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" + }, { "pathRelativity": "relativeToZap", "path": "../../../src/app/zap-templates/zcl/zcl-with-test-extensions.json", @@ -24,12 +30,6 @@ "category": "matter", "version": 1, "description": "Matter SDK ZCL data with some extensions" - }, - { - "pathRelativity": "relativeToZap", - "path": "../../../src/app/zap-templates/app-templates.json", - "type": "gen-templates-json", - "version": "chip-v1" } ], "endpointTypes": [ @@ -6512,120 +6512,107 @@ ] }, { - "name": "Scenes Management", - "code": 98, + "name": "On/Off", + "code": 6, "mfgCode": null, - "define": "SCENES_CLUSTER", - "side": "server", + "define": "ON_OFF_CLUSTER", + "side": "client", "enabled": 1, - "apiMaturity": "provisional", "commands": [ { - "name": "AddScene", + "name": "Off", "code": 0, "mfgCode": null, "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "AddSceneResponse", - "code": 0, - "mfgCode": null, - "source": "server", "isIncoming": 0, "isEnabled": 1 }, { - "name": "ViewScene", + "name": "On", "code": 1, "mfgCode": null, "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "ViewSceneResponse", - "code": 1, - "mfgCode": null, - "source": "server", "isIncoming": 0, "isEnabled": 1 }, { - "name": "RemoveScene", + "name": "Toggle", "code": 2, "mfgCode": null, "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "RemoveSceneResponse", - "code": 2, - "mfgCode": null, - "source": "server", "isIncoming": 0, "isEnabled": 1 - }, + } + ], + "attributes": [ { - "name": "RemoveAllScenes", - "code": 3, + "name": "FeatureMap", + "code": 65532, "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 }, { - "name": "RemoveAllScenesResponse", - "code": 3, + "name": "ClusterRevision", + "code": 65533, "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "5", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "On/Off", + "code": 6, + "mfgCode": null, + "define": "ON_OFF_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [ { - "name": "StoreScene", - "code": 4, + "name": "Off", + "code": 0, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 }, { - "name": "StoreSceneResponse", - "code": 4, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RecallScene", - "code": 5, + "name": "On", + "code": 1, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 }, { - "name": "GetSceneMembership", - "code": 6, + "name": "Toggle", + "code": 2, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 }, { - "name": "GetSceneMembershipResponse", - "code": 6, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "EnhancedAddScene", + "name": "OffWithEffect", "code": 64, "mfgCode": null, "source": "client", @@ -6633,15 +6620,7 @@ "isEnabled": 1 }, { - "name": "EnhancedAddSceneResponse", - "code": 64, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "EnhancedViewScene", + "name": "OnWithRecallGlobalScene", "code": 65, "mfgCode": null, "source": "client", @@ -6649,66 +6628,66 @@ "isEnabled": 1 }, { - "name": "EnhancedViewSceneResponse", - "code": 65, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "CopyScene", + "name": "OnWithTimedOff", "code": 66, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 - }, - { - "name": "CopySceneResponse", - "code": 66, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 } ], "attributes": [ { - "name": "NameSupport", - "code": 4, + "name": "OnOff", + "code": 0, "mfgCode": null, "side": "server", - "type": "NameSupportBitmap", + "type": "boolean", + "included": 1, + "storageOption": "NVM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x00", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "GlobalSceneControl", + "code": 16384, + "mfgCode": null, + "side": "server", + "type": "boolean", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x80", + "defaultValue": "0x01", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "LastConfiguredBy", - "code": 5, + "name": "OnTime", + "code": 16385, "mfgCode": null, "side": "server", - "type": "node_id", + "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "0x0000", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "SceneTableSize", - "code": 6, + "name": "OffWaitTime", + "code": 16386, "mfgCode": null, "side": "server", "type": "int16u", @@ -6716,26 +6695,26 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "16", + "defaultValue": "0x0000", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "FabricSceneInfo", - "code": 7, + "name": "StartUpOnOff", + "code": 16387, "mfgCode": null, "side": "server", - "type": "array", + "type": "StartUpOnOffEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0xFF", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { @@ -6812,10 +6791,10 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "15", + "defaultValue": "0x0001", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { @@ -6837,44 +6816,51 @@ ] }, { - "name": "On/Off", - "code": 6, + "name": "On/off Switch Configuration", + "code": 7, "mfgCode": null, - "define": "ON_OFF_CLUSTER", - "side": "client", + "define": "ON_OFF_SWITCH_CONFIGURATION_CLUSTER", + "side": "server", "enabled": 1, - "commands": [ + "apiMaturity": "deprecated", + "attributes": [ { - "name": "Off", + "name": "switch type", "code": 0, "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 + "side": "server", + "type": "enum8", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 }, { - "name": "On", - "code": 1, + "name": "switch actions", + "code": 16, "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 + "side": "server", + "type": "enum8", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x00", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 }, - { - "name": "Toggle", - "code": 2, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - } - ], - "attributes": [ { "name": "FeatureMap", "code": 65532, "mfgCode": null, - "side": "client", + "side": "server", "type": "bitmap32", "included": 1, "storageOption": "RAM", @@ -6890,13 +6876,13 @@ "name": "ClusterRevision", "code": 65533, "mfgCode": null, - "side": "client", + "side": "server", "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "5", + "defaultValue": "1", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -6905,15 +6891,15 @@ ] }, { - "name": "On/Off", - "code": 6, + "name": "Level Control", + "code": 8, "mfgCode": null, - "define": "ON_OFF_CLUSTER", + "define": "LEVEL_CONTROL_CLUSTER", "side": "server", "enabled": 1, "commands": [ { - "name": "Off", + "name": "MoveToLevel", "code": 0, "mfgCode": null, "source": "client", @@ -6921,7 +6907,7 @@ "isEnabled": 1 }, { - "name": "On", + "name": "Move", "code": 1, "mfgCode": null, "source": "client", @@ -6929,7 +6915,7 @@ "isEnabled": 1 }, { - "name": "Toggle", + "name": "Step", "code": 2, "mfgCode": null, "source": "client", @@ -6937,24 +6923,40 @@ "isEnabled": 1 }, { - "name": "OffWithEffect", - "code": 64, + "name": "Stop", + "code": 3, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 }, { - "name": "OnWithRecallGlobalScene", - "code": 65, + "name": "MoveToLevelWithOnOff", + "code": 4, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 }, { - "name": "OnWithTimedOff", - "code": 66, + "name": "MoveWithOnOff", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "StepWithOnOff", + "code": 6, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "StopWithOnOff", + "code": 7, "mfgCode": null, "source": "client", "isIncoming": 1, @@ -6963,168 +6965,168 @@ ], "attributes": [ { - "name": "OnOff", + "name": "CurrentLevel", "code": 0, "mfgCode": null, "side": "server", - "type": "boolean", + "type": "int8u", "included": 1, "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": "0x00", + "defaultValue": "0xFE", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "GlobalSceneControl", - "code": 16384, + "name": "RemainingTime", + "code": 1, "mfgCode": null, "side": "server", - "type": "boolean", + "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x01", + "defaultValue": "0x0000", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "OnTime", - "code": 16385, + "name": "MinLevel", + "code": 2, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "int8u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": "0x01", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OffWaitTime", - "code": 16386, + "name": "MaxLevel", + "code": 3, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "int8u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": "0xFE", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "StartUpOnOff", - "code": 16387, + "name": "CurrentFrequency", + "code": 4, "mfgCode": null, "side": "server", - "type": "StartUpOnOffEnum", + "type": "int16u", "included": 1, - "storageOption": "NVM", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": "0x0000", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "GeneratedCommandList", - "code": 65528, + "name": "MinFrequency", + "code": 5, "mfgCode": null, "side": "server", - "type": "array", + "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0x0000", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AcceptedCommandList", - "code": 65529, + "name": "MaxFrequency", + "code": 6, "mfgCode": null, "side": "server", - "type": "array", + "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0x0000", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "EventList", - "code": 65530, + "name": "Options", + "code": 15, "mfgCode": null, "side": "server", - "type": "array", + "type": "OptionsBitmap", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0x00", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "AttributeList", - "code": 65531, + "name": "OnOffTransitionTime", + "code": 16, "mfgCode": null, "side": "server", - "type": "array", + "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0x0000", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "FeatureMap", - "code": 65532, + "name": "OnLevel", + "code": 17, "mfgCode": null, "side": "server", - "type": "bitmap32", + "type": "int8u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0001", + "defaultValue": "0xFF", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "ClusterRevision", - "code": 65533, + "name": "OnTransitionTime", + "code": 18, "mfgCode": null, "side": "server", "type": "int16u", @@ -7132,50 +7134,55 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "5", + "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 - } - ] - }, - { - "name": "On/off Switch Configuration", - "code": 7, - "mfgCode": null, - "define": "ON_OFF_SWITCH_CONFIGURATION_CLUSTER", - "side": "server", - "enabled": 1, - "apiMaturity": "deprecated", - "attributes": [ + }, { - "name": "switch type", - "code": 0, + "name": "OffTransitionTime", + "code": 19, "mfgCode": null, "side": "server", - "type": "enum8", + "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "switch actions", - "code": 16, + "name": "DefaultMoveRate", + "code": 20, "mfgCode": null, "side": "server", - "type": "enum8", + "type": "int8u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x00", + "defaultValue": "50", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "StartUpCurrentLevel", + "code": 16384, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "NVM", + "singleton": 0, + "bounded": 0, + "defaultValue": "255", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -7191,7 +7198,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "3", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -7207,7 +7214,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "5", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -7216,146 +7223,81 @@ ] }, { - "name": "Level Control", - "code": 8, + "name": "Binary Input (Basic)", + "code": 15, "mfgCode": null, - "define": "LEVEL_CONTROL_CLUSTER", + "define": "BINARY_INPUT_BASIC_CLUSTER", "side": "server", "enabled": 1, - "commands": [ + "apiMaturity": "deprecated", + "attributes": [ { - "name": "MoveToLevel", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "Move", - "code": 1, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "Step", - "code": 2, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "Stop", - "code": 3, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "MoveToLevelWithOnOff", - "code": 4, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "MoveWithOnOff", - "code": 5, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "StepWithOnOff", - "code": 6, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "StopWithOnOff", - "code": 7, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "CurrentLevel", - "code": 0, + "name": "out of service", + "code": 81, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "boolean", "included": 1, - "storageOption": "NVM", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFE", + "defaultValue": "0x00", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "RemainingTime", - "code": 1, + "name": "present value", + "code": 85, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "boolean", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": "", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "MinLevel", - "code": 2, + "name": "status flags", + "code": 111, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "bitmap8", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x01", + "defaultValue": "0x00", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "MaxLevel", - "code": 3, + "name": "FeatureMap", + "code": 65532, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "bitmap32", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0xFE", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "CurrentFrequency", - "code": 4, + "name": "ClusterRevision", + "code": 65533, "mfgCode": null, "side": "server", "type": "int16u", @@ -7363,154 +7305,164 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": "1", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 - }, + } + ] + }, + { + "name": "Descriptor", + "code": 29, + "mfgCode": null, + "define": "DESCRIPTOR_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ { - "name": "MinFrequency", - "code": 5, + "name": "DeviceTypeList", + "code": 0, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": null, "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "MaxFrequency", - "code": 6, + "name": "ServerList", + "code": 1, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": null, "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "Options", - "code": 15, + "name": "ClientList", + "code": 2, "mfgCode": null, "side": "server", - "type": "OptionsBitmap", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0x00", + "defaultValue": null, "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "OnOffTransitionTime", - "code": 16, + "name": "PartsList", + "code": 3, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0x0000", + "defaultValue": null, "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "OnLevel", - "code": 17, + "name": "TagList", + "code": 4, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0xFF", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OnTransitionTime", - "code": 18, + "name": "GeneratedCommandList", + "code": 65528, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OffTransitionTime", - "code": 19, + "name": "AcceptedCommandList", + "code": 65529, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "DefaultMoveRate", - "code": 20, + "name": "EventList", + "code": 65530, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "50", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "StartUpCurrentLevel", - "code": 16384, + "name": "AttributeList", + "code": 65531, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "array", "included": 1, - "storageOption": "NVM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "255", + "defaultValue": null, "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { @@ -7523,7 +7475,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "3", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -7536,10 +7488,10 @@ "side": "server", "type": "int16u", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "5", + "defaultValue": null, "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -7548,57 +7500,114 @@ ] }, { - "name": "Binary Input (Basic)", - "code": 15, + "name": "Binding", + "code": 30, "mfgCode": null, - "define": "BINARY_INPUT_BASIC_CLUSTER", + "define": "BINDING_CLUSTER", "side": "server", "enabled": 1, - "apiMaturity": "deprecated", "attributes": [ { - "name": "out of service", - "code": 81, + "name": "Binding", + "code": 0, "mfgCode": null, "side": "server", - "type": "boolean", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0x00", + "defaultValue": null, "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "present value", - "code": 85, - "mfgCode": null, + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, "side": "server", - "type": "boolean", + "type": "bitmap32", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "Actions", + "code": 37, + "mfgCode": null, + "define": "ACTIONS_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "ActionList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "status flags", - "code": 111, + "name": "EndpointLists", + "code": 1, "mfgCode": null, "side": "server", - "type": "bitmap8", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0x00", + "defaultValue": null, + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "SetupURL", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "long_char_string", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -7627,7 +7636,7 @@ "side": "server", "type": "int16u", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "1", @@ -7639,80 +7648,112 @@ ] }, { - "name": "Descriptor", - "code": 29, + "name": "Power Source", + "code": 47, "mfgCode": null, - "define": "DESCRIPTOR_CLUSTER", + "define": "POWER_SOURCE_CLUSTER", "side": "server", "enabled": 1, "attributes": [ { - "name": "DeviceTypeList", + "name": "Status", "code": 0, "mfgCode": null, "side": "server", - "type": "array", + "type": "PowerSourceStatusEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "ServerList", + "name": "Order", "code": 1, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "2", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "ClientList", + "name": "Description", "code": 2, "mfgCode": null, "side": "server", - "type": "array", + "type": "char_string", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "B2", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "PartsList", - "code": 3, + "name": "BatChargeLevel", + "code": 14, "mfgCode": null, "side": "server", - "type": "array", + "type": "BatChargeLevelEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 }, { - "name": "TagList", - "code": 4, + "name": "BatReplacementNeeded", + "code": 15, + "mfgCode": null, + "side": "server", + "type": "boolean", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "BatReplaceability", + "code": 16, + "mfgCode": null, + "side": "server", + "type": "BatReplaceabilityEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EndpointList", + "code": 31, "mfgCode": null, "side": "server", "type": "array", @@ -7800,7 +7841,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -7813,39 +7854,64 @@ "side": "server", "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "2", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 } + ], + "events": [ + { + "name": "BatFaultChange", + "code": 1, + "mfgCode": null, + "side": "server", + "included": 1 + } ] }, { - "name": "Binding", - "code": 30, + "name": "Switch", + "code": 59, "mfgCode": null, - "define": "BINDING_CLUSTER", + "define": "SWITCH_CLUSTER", "side": "server", "enabled": 1, "attributes": [ { - "name": "Binding", + "name": "NumberOfPositions", "code": 0, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "2", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "CurrentPosition", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { @@ -7858,10 +7924,10 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "1", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { @@ -7880,18 +7946,27 @@ "maxInterval": 65344, "reportableChange": 0 } + ], + "events": [ + { + "name": "SwitchLatched", + "code": 0, + "mfgCode": null, + "side": "server", + "included": 1 + } ] }, { - "name": "Actions", - "code": 37, + "name": "Fixed Label", + "code": 64, "mfgCode": null, - "define": "ACTIONS_CLUSTER", + "define": "FIXED_LABEL_CLUSTER", "side": "server", "enabled": 1, "attributes": [ { - "name": "ActionList", + "name": "LabelList", "code": 0, "mfgCode": null, "side": "server", @@ -7907,43 +7982,69 @@ "reportableChange": 0 }, { - "name": "EndpointLists", - "code": 1, + "name": "FeatureMap", + "code": 65532, "mfgCode": null, "side": "server", - "type": "array", + "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "SetupURL", - "code": 2, + "name": "ClusterRevision", + "code": 65533, "mfgCode": null, "side": "server", - "type": "long_char_string", + "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "1", "reportable": 1, "minInterval": 0, "maxInterval": 65344, "reportableChange": 0 - }, - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "server", - "type": "bitmap32", + } + ] + }, + { + "name": "User Label", + "code": 65, + "mfgCode": null, + "define": "USER_LABEL_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "LabelList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", "included": 1, "storageOption": "RAM", "singleton": 0, @@ -7961,97 +8062,124 @@ "side": "server", "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, "defaultValue": "1", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 } ] }, { - "name": "Power Source", - "code": 47, + "name": "Boolean State", + "code": 69, "mfgCode": null, - "define": "POWER_SOURCE_CLUSTER", + "define": "BOOLEAN_STATE_CLUSTER", "side": "server", "enabled": 1, "attributes": [ { - "name": "Status", + "name": "StateValue", "code": 0, "mfgCode": null, "side": "server", - "type": "PowerSourceStatusEnum", + "type": "boolean", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, "defaultValue": "0", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "Order", - "code": 1, + "name": "FeatureMap", + "code": 65532, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "bitmap32", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "0", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "Description", - "code": 2, + "name": "ClusterRevision", + "code": 65533, "mfgCode": null, "side": "server", - "type": "char_string", + "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "B2", + "defaultValue": "1", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Oven Cavity Operational State", + "code": 72, + "mfgCode": null, + "define": "OPERATIONAL_STATE_OVEN_CLUSTER", + "side": "server", + "enabled": 1, + "apiMaturity": "provisional", + "attributes": [ + { + "name": "PhaseList", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "BatChargeLevel", - "code": 14, + "name": "CurrentPhase", + "code": 1, "mfgCode": null, "side": "server", - "type": "BatChargeLevelEnum", + "type": "int8u", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "BatReplacementNeeded", - "code": 15, + "name": "OperationalStateList", + "code": 3, "mfgCode": null, "side": "server", - "type": "boolean", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -8061,13 +8189,13 @@ "reportableChange": 0 }, { - "name": "BatReplaceability", - "code": 16, + "name": "OperationalState", + "code": 4, "mfgCode": null, "side": "server", - "type": "BatReplaceabilityEnum", + "type": "OperationalStateEnum", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -8077,16 +8205,16 @@ "reportableChange": 0 }, { - "name": "EndpointList", - "code": 31, + "name": "OperationalError", + "code": 5, "mfgCode": null, "side": "server", - "type": "array", + "type": "ErrorStateStruct", "included": 1, "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8166,7 +8294,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8182,117 +8310,105 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "1", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 } - ], - "events": [ - { - "name": "BatFaultChange", - "code": 1, - "mfgCode": null, - "side": "server", - "included": 1 - } ] }, { - "name": "Switch", - "code": 59, + "name": "Laundry Dryer Controls", + "code": 74, "mfgCode": null, - "define": "SWITCH_CLUSTER", + "define": "LAUNDRY_DRYER_CONTROLS_CLUSTER", "side": "server", "enabled": 1, "attributes": [ { - "name": "NumberOfPositions", + "name": "SupportedDrynessLevels", "code": 0, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "CurrentPosition", + "name": "SelectedDrynessLevel", "code": 1, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "DrynessLevelEnum", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "FeatureMap", - "code": 65532, + "name": "GeneratedCommandList", + "code": 65528, "mfgCode": null, "side": "server", - "type": "bitmap32", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { - "name": "ClusterRevision", - "code": 65533, + "name": "AcceptedCommandList", + "code": 65529, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 - } - ], - "events": [ + }, { - "name": "SwitchLatched", - "code": 0, + "name": "EventList", + "code": 65530, "mfgCode": null, "side": "server", - "included": 1 - } - ] - }, - { - "name": "Fixed Label", - "code": 64, - "mfgCode": null, - "define": "FIXED_LABEL_CLUSTER", - "side": "server", - "enabled": 1, - "attributes": [ + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { - "name": "LabelList", - "code": 0, + "name": "AttributeList", + "code": 65531, "mfgCode": null, "side": "server", "type": "array", @@ -8300,10 +8416,10 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 }, { @@ -8334,100 +8450,52 @@ "bounded": 0, "defaultValue": "1", "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, + "minInterval": 1, + "maxInterval": 65534, "reportableChange": 0 } ] }, { - "name": "User Label", - "code": 65, + "name": "Mode Select", + "code": 80, "mfgCode": null, - "define": "USER_LABEL_CLUSTER", + "define": "MODE_SELECT_CLUSTER", "side": "server", "enabled": 1, - "attributes": [ + "commands": [ { - "name": "LabelList", + "name": "ChangeToMode", "code": 0, "mfgCode": null, - "side": "server", - "type": "array", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "server", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "server", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "client", + "isIncoming": 1, + "isEnabled": 1 } - ] - }, - { - "name": "Boolean State", - "code": 69, - "mfgCode": null, - "define": "BOOLEAN_STATE_CLUSTER", - "side": "server", - "enabled": 1, + ], "attributes": [ { - "name": "StateValue", + "name": "Description", "code": 0, "mfgCode": null, "side": "server", - "type": "boolean", + "type": "char_string", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "Coffee", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "FeatureMap", - "code": 65532, + "name": "StandardNamespace", + "code": 1, "mfgCode": null, "side": "server", - "type": "bitmap32", + "type": "enum16", "included": 1, "storageOption": "RAM", "singleton": 0, @@ -8439,35 +8507,8 @@ "reportableChange": 0 }, { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "server", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - } - ] - }, - { - "name": "Oven Cavity Operational State", - "code": 72, - "mfgCode": null, - "define": "OPERATIONAL_STATE_OVEN_CLUSTER", - "side": "server", - "enabled": 1, - "apiMaturity": "provisional", - "attributes": [ - { - "name": "PhaseList", - "code": 0, + "name": "SupportedModes", + "code": 2, "mfgCode": null, "side": "server", "type": "array", @@ -8482,64 +8523,48 @@ "reportableChange": 0 }, { - "name": "CurrentPhase", - "code": 1, - "mfgCode": null, - "side": "server", - "type": "int8u", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "OperationalStateList", + "name": "CurrentMode", "code": 3, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OperationalState", + "name": "StartUpMode", "code": 4, "mfgCode": null, "side": "server", - "type": "OperationalStateEnum", + "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OperationalError", + "name": "OnMode", "code": 5, "mfgCode": null, "side": "server", - "type": "ErrorStateStruct", + "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "255", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8578,8 +8603,8 @@ "reportableChange": 0 }, { - "name": "EventList", - "code": 65530, + "name": "AttributeList", + "code": 65531, "mfgCode": null, "side": "server", "type": "array", @@ -8594,48 +8619,48 @@ "reportableChange": 0 }, { - "name": "AttributeList", - "code": 65531, + "name": "FeatureMap", + "code": 65532, "mfgCode": null, "side": "server", - "type": "array", + "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "FeatureMap", - "code": 65532, + "name": "ClusterRevision", + "code": 65533, "mfgCode": null, "side": "server", - "type": "bitmap32", + "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "ClusterRevision", - "code": 65533, + "name": "ManufacturerExtension", + "code": 4293984257, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "int8u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "255", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8644,15 +8669,33 @@ ] }, { - "name": "Laundry Dryer Controls", - "code": 74, + "name": "Laundry Washer Mode", + "code": 81, "mfgCode": null, - "define": "LAUNDRY_DRYER_CONTROLS_CLUSTER", + "define": "LAUNDRY_WASHER_MODE_CLUSTER", "side": "server", "enabled": 1, + "commands": [ + { + "name": "ChangeToMode", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "ChangeToModeResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], "attributes": [ { - "name": "SupportedDrynessLevels", + "name": "SupportedModes", "code": 0, "mfgCode": null, "side": "server", @@ -8661,63 +8704,63 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "SelectedDrynessLevel", + "name": "CurrentMode", "code": 1, "mfgCode": null, "side": "server", - "type": "DrynessLevelEnum", + "type": "int8u", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "GeneratedCommandList", - "code": 65528, + "name": "StartUpMode", + "code": 2, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", "included": 1, "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AcceptedCommandList", - "code": 65529, + "name": "OnMode", + "code": 3, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", "included": 1, "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "EventList", - "code": 65530, + "name": "GeneratedCommandList", + "code": 65528, "mfgCode": null, "side": "server", "type": "array", @@ -8725,15 +8768,15 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AttributeList", - "code": 65531, + "name": "AcceptedCommandList", + "code": 65529, "mfgCode": null, "side": "server", "type": "array", @@ -8741,30 +8784,46 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "FeatureMap", - "code": 65532, + "name": "AttributeList", + "code": 65531, "mfgCode": null, "side": "server", - "type": "bitmap32", + "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "ClusterRevision", + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", "code": 65533, "mfgCode": null, "side": "server", @@ -8773,7 +8832,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8782,10 +8841,10 @@ ] }, { - "name": "Mode Select", - "code": 80, + "name": "Refrigerator And Temperature Controlled Cabinet Mode", + "code": 82, "mfgCode": null, - "define": "MODE_SELECT_CLUSTER", + "define": "REFRIGERATOR_AND_TEMPERATURE_CONTROLLED_CABINET_MODE_CLUSTER", "side": "server", "enabled": 1, "commands": [ @@ -8796,44 +8855,20 @@ "source": "client", "isIncoming": 1, "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "Description", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "Coffee", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 }, { - "name": "StandardNamespace", + "name": "ChangeToModeResponse", "code": 1, "mfgCode": null, - "side": "server", - "type": "enum16", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ { "name": "SupportedModes", - "code": 2, + "code": 0, "mfgCode": null, "side": "server", "type": "array", @@ -8849,15 +8884,15 @@ }, { "name": "CurrentMode", - "code": 3, + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "NVM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8865,15 +8900,15 @@ }, { "name": "StartUpMode", - "code": 4, + "code": 2, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "NVM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8881,15 +8916,15 @@ }, { "name": "OnMode", - "code": 5, + "code": 3, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "NVM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "255", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8950,10 +8985,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8974,53 +9009,19 @@ "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 - }, - { - "name": "ManufacturerExtension", - "code": 4293984257, - "mfgCode": null, - "side": "server", - "type": "int8u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "255", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 } ] }, { - "name": "Laundry Washer Mode", - "code": 81, + "name": "Laundry Washer Controls", + "code": 83, "mfgCode": null, - "define": "LAUNDRY_WASHER_MODE_CLUSTER", + "define": "LAUNDRY_WASHER_CONTROLS_CLUSTER", "side": "server", "enabled": 1, - "commands": [ - { - "name": "ChangeToMode", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "ChangeToModeResponse", - "code": 1, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - } - ], "attributes": [ { - "name": "SupportedModes", + "name": "SpinSpeeds", "code": 0, "mfgCode": null, "side": "server", @@ -9036,43 +9037,43 @@ "reportableChange": 0 }, { - "name": "CurrentMode", + "name": "SpinSpeedCurrent", "code": 1, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "StartUpMode", + "name": "NumberOfRinses", "code": 2, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "NumberOfRinsesEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OnMode", + "name": "SupportedRinses", "code": 3, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "array", "included": 1, "storageOption": "External", "singleton": 0, @@ -9115,6 +9116,22 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "AttributeList", "code": 65531, @@ -9138,10 +9155,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "3", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9157,7 +9174,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9166,10 +9183,10 @@ ] }, { - "name": "Refrigerator And Temperature Controlled Cabinet Mode", - "code": 82, + "name": "RVC Run Mode", + "code": 84, "mfgCode": null, - "define": "REFRIGERATOR_AND_TEMPERATURE_CONTROLLED_CABINET_MODE_CLUSTER", + "define": "RVC_RUN_MODE_CLUSTER", "side": "server", "enabled": 1, "commands": [ @@ -9223,22 +9240,6 @@ "maxInterval": 65534, "reportableChange": 0 }, - { - "name": "StartUpMode", - "code": 2, - "mfgCode": null, - "side": "server", - "type": "int8u", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "OnMode", "code": 3, @@ -9338,15 +9339,33 @@ ] }, { - "name": "Laundry Washer Controls", - "code": 83, + "name": "RVC Clean Mode", + "code": 85, "mfgCode": null, - "define": "LAUNDRY_WASHER_CONTROLS_CLUSTER", + "define": "RVC_CLEAN_MODE_CLUSTER", "side": "server", "enabled": 1, + "commands": [ + { + "name": "ChangeToMode", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "ChangeToModeResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], "attributes": [ { - "name": "SpinSpeeds", + "name": "SupportedModes", "code": 0, "mfgCode": null, "side": "server", @@ -9362,43 +9381,27 @@ "reportableChange": 0 }, { - "name": "SpinSpeedCurrent", + "name": "CurrentMode", "code": 1, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "NumberOfRinses", - "code": 2, - "mfgCode": null, - "side": "server", - "type": "NumberOfRinsesEnum", - "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "SupportedRinses", + "name": "OnMode", "code": 3, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", "included": 1, "storageOption": "External", "singleton": 0, @@ -9442,8 +9445,8 @@ "reportableChange": 0 }, { - "name": "EventList", - "code": 65530, + "name": "AttributeList", + "code": 65531, "mfgCode": null, "side": "server", "type": "array", @@ -9458,11 +9461,11 @@ "reportableChange": 0 }, { - "name": "AttributeList", - "code": 65531, + "name": "FeatureMap", + "code": 65532, "mfgCode": null, "side": "server", - "type": "array", + "type": "bitmap32", "included": 1, "storageOption": "External", "singleton": 0, @@ -9473,22 +9476,6 @@ "maxInterval": 65534, "reportableChange": 0 }, - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "server", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "3", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "ClusterRevision", "code": 65533, @@ -9499,7 +9486,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9508,69 +9495,45 @@ ] }, { - "name": "RVC Run Mode", - "code": 84, + "name": "Temperature Control", + "code": 86, "mfgCode": null, - "define": "RVC_RUN_MODE_CLUSTER", + "define": "TEMPERATURE_CONTROL_CLUSTER", "side": "server", "enabled": 1, "commands": [ { - "name": "ChangeToMode", + "name": "SetTemperature", "code": 0, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 - }, - { - "name": "ChangeToModeResponse", - "code": 1, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 } ], "attributes": [ { - "name": "SupportedModes", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "array", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "CurrentMode", - "code": 1, + "name": "SelectedTemperatureLevel", + "code": 4, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OnMode", - "code": 3, + "name": "SupportedTemperatureLevels", + "code": 5, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "array", "included": 1, "storageOption": "External", "singleton": 0, @@ -9636,10 +9599,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9655,7 +9618,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9664,74 +9627,56 @@ ] }, { - "name": "RVC Clean Mode", - "code": 85, + "name": "Refrigerator Alarm", + "code": 87, "mfgCode": null, - "define": "RVC_CLEAN_MODE_CLUSTER", + "define": "REFRIGERATOR_ALARM_CLUSTER", "side": "server", "enabled": 1, - "commands": [ - { - "name": "ChangeToMode", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "ChangeToModeResponse", - "code": 1, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - } - ], "attributes": [ { - "name": "SupportedModes", + "name": "Mask", "code": 0, "mfgCode": null, "side": "server", - "type": "array", + "type": "AlarmMap", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "CurrentMode", - "code": 1, + "name": "State", + "code": 2, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "AlarmMap", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OnMode", + "name": "Supported", "code": 3, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "AlarmMap", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9792,10 +9737,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9811,54 +9756,103 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 } + ], + "events": [ + { + "name": "Notify", + "code": 0, + "mfgCode": null, + "side": "server", + "included": 1 + } ] }, { - "name": "Temperature Control", - "code": 86, + "name": "Dishwasher Mode", + "code": 89, "mfgCode": null, - "define": "TEMPERATURE_CONTROL_CLUSTER", + "define": "DISHWASHER_MODE_CLUSTER", "side": "server", "enabled": 1, "commands": [ { - "name": "SetTemperature", + "name": "ChangeToMode", "code": 0, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 + }, + { + "name": "ChangeToModeResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 } ], "attributes": [ { - "name": "SelectedTemperatureLevel", - "code": 4, + "name": "SupportedModes", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "CurrentMode", + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "SupportedTemperatureLevels", - "code": 5, + "name": "StartUpMode", + "code": 2, "mfgCode": null, "side": "server", - "type": "array", + "type": "int8u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "OnMode", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "int8u", "included": 1, "storageOption": "External", "singleton": 0, @@ -9924,10 +9918,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9943,7 +9937,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -9952,56 +9946,24 @@ ] }, { - "name": "Refrigerator Alarm", - "code": 87, + "name": "Air Quality", + "code": 91, "mfgCode": null, - "define": "REFRIGERATOR_ALARM_CLUSTER", + "define": "AIR_QUALITY_CLUSTER", "side": "server", "enabled": 1, "attributes": [ { - "name": "Mask", + "name": "AirQuality", "code": 0, "mfgCode": null, "side": "server", - "type": "AlarmMap", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "State", - "code": 2, - "mfgCode": null, - "side": "server", - "type": "AlarmMap", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "Supported", - "code": 3, - "mfgCode": null, - "side": "server", - "type": "AlarmMap", + "type": "AirQualityEnum", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -10062,10 +10024,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -10087,256 +10049,229 @@ "maxInterval": 65534, "reportableChange": 0 } - ], - "events": [ - { - "name": "Notify", - "code": 0, - "mfgCode": null, - "side": "server", - "included": 1 - } ] }, { - "name": "Dishwasher Mode", - "code": 89, + "name": "Smoke CO Alarm", + "code": 92, "mfgCode": null, - "define": "DISHWASHER_MODE_CLUSTER", + "define": "SMOKE_CO_ALARM_CLUSTER", "side": "server", "enabled": 1, "commands": [ { - "name": "ChangeToMode", + "name": "SelfTestRequest", "code": 0, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 - }, - { - "name": "ChangeToModeResponse", - "code": 1, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 } ], "attributes": [ { - "name": "SupportedModes", + "name": "ExpressedState", "code": 0, "mfgCode": null, "side": "server", - "type": "array", + "type": "ExpressedStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "CurrentMode", + "name": "SmokeState", "code": 1, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "AlarmStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "StartUpMode", + "name": "COState", "code": 2, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "AlarmStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "OnMode", + "name": "BatteryAlert", "code": 3, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "AlarmStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "GeneratedCommandList", - "code": 65528, + "name": "DeviceMuted", + "code": 4, "mfgCode": null, "side": "server", - "type": "array", + "type": "MuteStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AcceptedCommandList", - "code": 65529, + "name": "TestInProgress", + "code": 5, "mfgCode": null, "side": "server", - "type": "array", + "type": "boolean", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AttributeList", - "code": 65531, + "name": "HardwareFaultAlert", + "code": 6, "mfgCode": null, "side": "server", - "type": "array", + "type": "boolean", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "FeatureMap", - "code": 65532, + "name": "EndOfServiceAlert", + "code": 7, "mfgCode": null, "side": "server", - "type": "bitmap32", + "type": "EndOfServiceEnum", "included": 1, - "storageOption": "External", + "storageOption": "NVM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "ClusterRevision", - "code": 65533, + "name": "InterconnectSmokeAlarm", + "code": 8, "mfgCode": null, "side": "server", - "type": "int16u", + "type": "AlarmStateEnum", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 - } - ] - }, - { - "name": "Air Quality", - "code": 91, - "mfgCode": null, - "define": "AIR_QUALITY_CLUSTER", - "side": "server", - "enabled": 1, - "attributes": [ + }, { - "name": "AirQuality", - "code": 0, + "name": "InterconnectCOAlarm", + "code": 9, "mfgCode": null, "side": "server", - "type": "AirQualityEnum", + "type": "AlarmStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "GeneratedCommandList", - "code": 65528, + "name": "ContaminationState", + "code": 10, "mfgCode": null, "side": "server", - "type": "array", + "type": "ContaminationStateEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AcceptedCommandList", - "code": 65529, + "name": "SmokeSensitivityLevel", + "code": 11, "mfgCode": null, "side": "server", - "type": "array", + "type": "SensitivityEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "1", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AttributeList", - "code": 65531, + "name": "ExpiryDate", + "code": 12, "mfgCode": null, "side": "server", - "type": "array", + "type": "epoch_s", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -10349,10 +10284,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "3", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -10374,312 +10309,52 @@ "maxInterval": 65534, "reportableChange": 0 } - ] - }, - { - "name": "Smoke CO Alarm", - "code": 92, - "mfgCode": null, - "define": "SMOKE_CO_ALARM_CLUSTER", - "side": "server", - "enabled": 1, - "commands": [ - { - "name": "SelfTestRequest", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - } ], - "attributes": [ + "events": [ { - "name": "ExpressedState", + "name": "SmokeAlarm", "code": 0, "mfgCode": null, "side": "server", - "type": "ExpressedStateEnum", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "included": 1 }, { - "name": "SmokeState", + "name": "COAlarm", "code": 1, "mfgCode": null, "side": "server", - "type": "AlarmStateEnum", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "included": 1 }, { - "name": "COState", + "name": "LowBattery", "code": 2, "mfgCode": null, "side": "server", - "type": "AlarmStateEnum", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "included": 1 }, { - "name": "BatteryAlert", + "name": "HardwareFault", "code": 3, "mfgCode": null, "side": "server", - "type": "AlarmStateEnum", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "included": 1 }, { - "name": "DeviceMuted", + "name": "EndOfService", "code": 4, "mfgCode": null, "side": "server", - "type": "MuteStateEnum", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "included": 1 }, { - "name": "TestInProgress", + "name": "SelfTestComplete", "code": 5, "mfgCode": null, "side": "server", - "type": "boolean", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "included": 1 }, { - "name": "HardwareFaultAlert", - "code": 6, - "mfgCode": null, - "side": "server", - "type": "boolean", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "EndOfServiceAlert", - "code": 7, - "mfgCode": null, - "side": "server", - "type": "EndOfServiceEnum", - "included": 1, - "storageOption": "NVM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "InterconnectSmokeAlarm", - "code": 8, - "mfgCode": null, - "side": "server", - "type": "AlarmStateEnum", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "InterconnectCOAlarm", - "code": 9, - "mfgCode": null, - "side": "server", - "type": "AlarmStateEnum", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ContaminationState", - "code": 10, - "mfgCode": null, - "side": "server", - "type": "ContaminationStateEnum", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "SmokeSensitivityLevel", - "code": 11, - "mfgCode": null, - "side": "server", - "type": "SensitivityEnum", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ExpiryDate", - "code": 12, - "mfgCode": null, - "side": "server", - "type": "epoch_s", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "server", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "3", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "server", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - } - ], - "events": [ - { - "name": "SmokeAlarm", - "code": 0, - "mfgCode": null, - "side": "server", - "included": 1 - }, - { - "name": "COAlarm", - "code": 1, - "mfgCode": null, - "side": "server", - "included": 1 - }, - { - "name": "LowBattery", - "code": 2, - "mfgCode": null, - "side": "server", - "included": 1 - }, - { - "name": "HardwareFault", - "code": 3, - "mfgCode": null, - "side": "server", - "included": 1 - }, - { - "name": "EndOfService", - "code": 4, - "mfgCode": null, - "side": "server", - "included": 1 - }, - { - "name": "SelfTestComplete", - "code": 5, - "mfgCode": null, - "side": "server", - "included": 1 - }, - { - "name": "AlarmMuted", + "name": "AlarmMuted", "code": 6, "mfgCode": null, "side": "server", @@ -11508,106 +11183,219 @@ ] }, { - "name": "HEPA Filter Monitoring", - "code": 113, + "name": "Scenes Management", + "code": 98, "mfgCode": null, - "define": "HEPA_FILTER_MONITORING_CLUSTER", + "define": "SCENES_CLUSTER", "side": "server", "enabled": 1, + "apiMaturity": "provisional", "commands": [ { - "name": "ResetCondition", + "name": "AddScene", "code": 0, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 - } - ], - "attributes": [ + }, { - "name": "Condition", + "name": "AddSceneResponse", "code": 0, "mfgCode": null, - "side": "server", - "type": "percent", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "server", + "isIncoming": 0, + "isEnabled": 1 }, { - "name": "DegradationDirection", + "name": "ViewScene", "code": 1, "mfgCode": null, - "side": "server", - "type": "DegradationDirectionEnum", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "client", + "isIncoming": 1, + "isEnabled": 1 }, { - "name": "ChangeIndication", - "code": 2, + "name": "ViewSceneResponse", + "code": 1, "mfgCode": null, - "side": "server", - "type": "ChangeIndicationEnum", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "server", + "isIncoming": 0, + "isEnabled": 1 }, { - "name": "InPlaceIndicator", - "code": 3, + "name": "RemoveScene", + "code": 2, "mfgCode": null, - "side": "server", - "type": "boolean", + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveSceneResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RemoveAllScenes", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveAllScenesResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "StoreScene", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "StoreSceneResponse", + "code": 4, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RecallScene", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "GetSceneMembership", + "code": 6, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "GetSceneMembershipResponse", + "code": 6, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "EnhancedAddScene", + "code": 64, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "EnhancedAddSceneResponse", + "code": 64, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "EnhancedViewScene", + "code": 65, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "EnhancedViewSceneResponse", + "code": 65, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "CopyScene", + "code": 66, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "CopySceneResponse", + "code": 66, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "NameSupport", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "NameSupportBitmap", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "0x80", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "LastConfiguredBy", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "node_id", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "LastChangedTime", - "code": 4, + "name": "SceneTableSize", + "code": 6, "mfgCode": null, "side": "server", - "type": "epoch_s", + "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "16", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "ReplacementProductList", - "code": 5, + "name": "FabricSceneInfo", + "code": 7, "mfgCode": null, "side": "server", "type": "array", @@ -11653,6 +11441,22 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "AttributeList", "code": 65531, @@ -11676,10 +11480,10 @@ "side": "server", "type": "bitmap32", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "15", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -11695,19 +11499,19 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "1", + "defaultValue": "5", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 } ] }, { - "name": "Activated Carbon Filter Monitoring", - "code": 114, + "name": "HEPA Filter Monitoring", + "code": 113, "mfgCode": null, - "define": "ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER", + "define": "HEPA_FILTER_MONITORING_CLUSTER", "side": "server", "enabled": 1, "commands": [ @@ -11900,132 +11704,328 @@ ] }, { - "name": "Boolean State Configuration", - "code": 128, + "name": "Activated Carbon Filter Monitoring", + "code": 114, "mfgCode": null, - "define": "BOOLEAN_STATE_CONFIGURATION_CLUSTER", + "define": "ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER", "side": "server", "enabled": 1, - "apiMaturity": "provisional", "commands": [ { - "name": "SuppressAlarm", + "name": "ResetCondition", "code": 0, "mfgCode": null, "source": "client", "isIncoming": 1, "isEnabled": 1 - }, - { - "name": "EnableDisableAlarm", - "code": 1, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 } ], "attributes": [ { - "name": "CurrentSensitivityLevel", + "name": "Condition", "code": 0, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "percent", "included": 1, "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "SupportedSensitivityLevels", + "name": "DegradationDirection", "code": 1, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "DegradationDirectionEnum", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "3", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "DefaultSensitivityLevel", + "name": "ChangeIndication", "code": 2, "mfgCode": null, "side": "server", - "type": "int8u", + "type": "ChangeIndicationEnum", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AlarmsActive", + "name": "InPlaceIndicator", "code": 3, "mfgCode": null, "side": "server", - "type": "AlarmModeBitmap", + "type": "boolean", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AlarmsSuppressed", + "name": "LastChangedTime", "code": 4, "mfgCode": null, "side": "server", - "type": "AlarmModeBitmap", + "type": "epoch_s", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AlarmsEnabled", + "name": "ReplacementProductList", "code": 5, "mfgCode": null, "side": "server", - "type": "AlarmModeBitmap", + "type": "array", "included": 1, - "storageOption": "NVM", + "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "AlarmsSupported", - "code": 6, - "mfgCode": null, + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Boolean State Configuration", + "code": 128, + "mfgCode": null, + "define": "BOOLEAN_STATE_CONFIGURATION_CLUSTER", + "side": "server", + "enabled": 1, + "apiMaturity": "provisional", + "commands": [ + { + "name": "SuppressAlarm", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "EnableDisableAlarm", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "CurrentSensitivityLevel", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "2", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "SupportedSensitivityLevels", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "3", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "DefaultSensitivityLevel", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "2", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AlarmsActive", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "AlarmModeBitmap", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AlarmsSuppressed", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "AlarmModeBitmap", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AlarmsEnabled", + "code": 5, + "mfgCode": null, + "side": "server", + "type": "AlarmModeBitmap", + "included": 1, + "storageOption": "NVM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AlarmsSupported", + "code": 6, + "mfgCode": null, "side": "server", "type": "AlarmModeBitmap", "included": 1, @@ -14618,128 +14618,56 @@ "source": "client", "isIncoming": 1, "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "LocalTemperature", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "temperature", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 }, { - "name": "GetRelayStatusLogResponse", - "code": 1, + "name": "AbsMinHeatSetpointLimit", + "code": 3, "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 0 + "side": "server", + "type": "temperature", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x02BC", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 }, { - "name": "GetRelayStatusLog", + "name": "AbsMaxHeatSetpointLimit", "code": 4, "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "SetActiveScheduleRequest", - "code": 5, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "SetActivePresetRequest", - "code": 6, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "StartPresetsSchedulesEditRequest", - "code": 7, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "CancelPresetsSchedulesEditRequest", - "code": 8, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "CommitPresetsSchedulesRequest", - "code": 9, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "CancelSetActivePresetRequest", - "code": 10, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - }, - { - "name": "SetTemperatureSetpointHoldPolicy", - "code": 11, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 0 - } - ], - "attributes": [ - { - "name": "LocalTemperature", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "temperature", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 - }, - { - "name": "AbsMinHeatSetpointLimit", - "code": 3, - "mfgCode": null, - "side": "server", - "type": "temperature", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0x02BC", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 - }, - { - "name": "AbsMaxHeatSetpointLimit", - "code": 4, - "mfgCode": null, - "side": "server", - "type": "temperature", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0x0BB8", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 + "side": "server", + "type": "temperature", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x0BB8", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 }, { "name": "AbsMinCoolSetpointLimit", @@ -22352,367 +22280,42 @@ "name": "RemoveGroupResponse", "code": 3, "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RemoveAllGroups", - "code": 4, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "AddGroupIfIdentifying", - "code": 5, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "NameSupport", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "NameSupportBitmap", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 - }, - { - "name": "GeneratedCommandList", - "code": 65528, - "mfgCode": null, - "side": "server", - "type": "array", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "AcceptedCommandList", - "code": 65529, - "mfgCode": null, - "side": "server", - "type": "array", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "EventList", - "code": 65530, - "mfgCode": null, - "side": "server", - "type": "array", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "AttributeList", - "code": 65531, - "mfgCode": null, - "side": "server", - "type": "array", - "included": 1, - "storageOption": "External", - "singleton": 0, - "bounded": 0, - "defaultValue": null, - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "FeatureMap", - "code": 65532, - "mfgCode": null, - "side": "server", - "type": "bitmap32", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "server", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "4", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 - } - ] - }, - { - "name": "Scenes Management", - "code": 98, - "mfgCode": null, - "define": "SCENES_CLUSTER", - "side": "server", - "enabled": 1, - "apiMaturity": "provisional", - "commands": [ - { - "name": "AddScene", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "AddSceneResponse", - "code": 0, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "ViewScene", - "code": 1, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "ViewSceneResponse", - "code": 1, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RemoveScene", - "code": 2, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "RemoveSceneResponse", - "code": 2, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RemoveAllScenes", - "code": 3, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "RemoveAllScenesResponse", - "code": 3, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "StoreScene", - "code": 4, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "StoreSceneResponse", - "code": 4, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RecallScene", - "code": 5, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "GetSceneMembership", - "code": 6, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "GetSceneMembershipResponse", - "code": 6, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "EnhancedAddScene", - "code": 64, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "EnhancedAddSceneResponse", - "code": 64, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "EnhancedViewScene", - "code": 65, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "EnhancedViewSceneResponse", - "code": 65, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "CopyScene", - "code": 66, - "mfgCode": null, - "source": "client", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "CopySceneResponse", - "code": 66, - "mfgCode": null, - "source": "server", - "isIncoming": 0, - "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "NameSupport", - "code": 4, - "mfgCode": null, - "side": "server", - "type": "NameSupportBitmap", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0x80", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 - }, - { - "name": "LastConfiguredBy", - "code": 5, - "mfgCode": null, - "side": "server", - "type": "node_id", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, - { - "name": "SceneTableSize", - "code": 6, - "mfgCode": null, - "side": "server", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "16", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "server", + "isIncoming": 0, + "isEnabled": 1 }, { - "name": "FabricSceneInfo", - "code": 7, + "name": "RemoveAllGroups", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "AddGroupIfIdentifying", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "NameSupport", + "code": 0, "mfgCode": null, "side": "server", - "type": "array", + "type": "NameSupportBitmap", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { @@ -22789,7 +22392,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "15", + "defaultValue": "0", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -22805,7 +22408,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "5", + "defaultValue": "4", "reportable": 1, "minInterval": 0, "maxInterval": 65344, @@ -23090,40 +22693,258 @@ "reportableChange": 0 }, { - "name": "ClientList", - "code": 2, + "name": "ClientList", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "PartsList", + "code": 3, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "TagList", + "code": 4, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Power Source", + "code": 47, + "mfgCode": null, + "define": "POWER_SOURCE_CLUSTER", + "side": "server", + "enabled": 1, + "attributes": [ + { + "name": "Status", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "PowerSourceStatusEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Order", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Description", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "char_string", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "B3", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "BatChargeLevel", + "code": 14, + "mfgCode": null, + "side": "server", + "type": "BatChargeLevelEnum", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "BatReplacementNeeded", + "code": 15, "mfgCode": null, "side": "server", - "type": "array", + "type": "boolean", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "PartsList", - "code": 3, + "name": "BatReplaceability", + "code": 16, "mfgCode": null, "side": "server", - "type": "array", + "type": "BatReplaceabilityEnum", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "TagList", - "code": 4, + "name": "EndpointList", + "code": 31, "mfgCode": null, "side": "server", "type": "array", @@ -23211,7 +23032,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -23224,10 +23045,10 @@ "side": "server", "type": "int16u", "included": 1, - "storageOption": "External", + "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "2", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -23236,83 +23057,190 @@ ] }, { - "name": "Power Source", - "code": 47, + "name": "Scenes Management", + "code": 98, "mfgCode": null, - "define": "POWER_SOURCE_CLUSTER", + "define": "SCENES_CLUSTER", "side": "server", "enabled": 1, - "attributes": [ + "apiMaturity": "provisional", + "commands": [ { - "name": "Status", + "name": "AddScene", "code": 0, "mfgCode": null, - "side": "server", - "type": "PowerSourceStatusEnum", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "0", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "client", + "isIncoming": 1, + "isEnabled": 1 }, { - "name": "Order", + "name": "AddSceneResponse", + "code": 0, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "ViewScene", "code": 1, "mfgCode": null, - "side": "server", - "type": "int8u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "1", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "client", + "isIncoming": 1, + "isEnabled": 1 }, { - "name": "Description", + "name": "ViewSceneResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RemoveScene", "code": 2, "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "B3", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 + "source": "client", + "isIncoming": 1, + "isEnabled": 1 }, { - "name": "BatChargeLevel", - "code": 14, + "name": "RemoveSceneResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RemoveAllScenes", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveAllScenesResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "StoreScene", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "StoreSceneResponse", + "code": 4, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RecallScene", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "GetSceneMembership", + "code": 6, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "GetSceneMembershipResponse", + "code": 6, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "EnhancedAddScene", + "code": 64, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "EnhancedAddSceneResponse", + "code": 64, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "EnhancedViewScene", + "code": 65, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "EnhancedViewSceneResponse", + "code": 65, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "CopyScene", + "code": 66, + "mfgCode": null, + "source": "client", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "CopySceneResponse", + "code": 66, + "mfgCode": null, + "source": "server", + "isIncoming": 0, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "NameSupport", + "code": 4, "mfgCode": null, "side": "server", - "type": "BatChargeLevelEnum", + "type": "NameSupportBitmap", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "0", + "defaultValue": "0x80", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 }, { - "name": "BatReplacementNeeded", - "code": 15, + "name": "LastConfiguredBy", + "code": 5, "mfgCode": null, "side": "server", - "type": "boolean", + "type": "node_id", "included": 1, "storageOption": "RAM", "singleton": 0, @@ -23324,24 +23252,24 @@ "reportableChange": 0 }, { - "name": "BatReplaceability", - "code": 16, + "name": "SceneTableSize", + "code": 6, "mfgCode": null, "side": "server", - "type": "BatReplaceabilityEnum", + "type": "int16u", "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": "16", "reportable": 1, "minInterval": 1, "maxInterval": 65534, "reportableChange": 0 }, { - "name": "EndpointList", - "code": 31, + "name": "FabricSceneInfo", + "code": 7, "mfgCode": null, "side": "server", "type": "array", @@ -23429,7 +23357,7 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "15", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -23445,10 +23373,10 @@ "storageOption": "RAM", "singleton": 0, "bounded": 0, - "defaultValue": "2", + "defaultValue": "5", "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, + "minInterval": 0, + "maxInterval": 65344, "reportableChange": 0 } ] diff --git a/examples/light-switch-app/qpg/zap/switch.matter b/examples/light-switch-app/qpg/zap/switch.matter index b0e5f87deffa58..82d8b7a51a1770 100644 --- a/examples/light-switch-app/qpg/zap/switch.matter +++ b/examples/light-switch-app/qpg/zap/switch.matter @@ -178,199 +178,6 @@ cluster Groups = 4 { fabric command access(invoke: manage) AddGroupIfIdentifying(AddGroupIfIdentifyingRequest): DefaultSuccess = 5; } -/** Attributes and commands for scene configuration and manipulation. */ -provisional cluster Scenes = 5 { - revision 5; - - bitmap CopyModeBitmap : bitmap8 { - kCopyAllScenes = 0x1; - } - - bitmap Feature : bitmap32 { - kSceneNames = 0x1; - kExplicit = 0x2; - kTableSize = 0x4; - kFabricScenes = 0x8; - } - - bitmap NameSupportBitmap : bitmap8 { - kSceneNames = 0x80; - } - - struct AttributeValuePair { - attrib_id attributeID = 0; - int32u attributeValue = 1; - } - - struct ExtensionFieldSet { - cluster_id clusterID = 0; - AttributeValuePair attributeValueList[] = 1; - } - - fabric_scoped struct SceneInfoStruct { - int8u sceneCount = 0; - fabric_sensitive int8u currentScene = 1; - fabric_sensitive group_id currentGroup = 2; - fabric_sensitive boolean sceneValid = 3; - int8u remainingCapacity = 4; - fabric_idx fabricIndex = 254; - } - - readonly attribute optional int8u sceneCount = 0; - readonly attribute optional int8u currentScene = 1; - readonly attribute optional group_id currentGroup = 2; - readonly attribute optional boolean sceneValid = 3; - readonly attribute NameSupportBitmap nameSupport = 4; - readonly attribute optional nullable node_id lastConfiguredBy = 5; - readonly attribute int16u sceneTableSize = 6; - readonly attribute SceneInfoStruct fabricSceneInfo[] = 7; - 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 AddSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - int16u transitionTime = 2; - char_string sceneName = 3; - ExtensionFieldSet extensionFieldSets[] = 4; - } - - response struct AddSceneResponse = 0 { - status status = 0; - group_id groupID = 1; - int8u sceneID = 2; - } - - request struct ViewSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - } - - response struct ViewSceneResponse = 1 { - status status = 0; - group_id groupID = 1; - int8u sceneID = 2; - optional int16u transitionTime = 3; - optional char_string sceneName = 4; - optional ExtensionFieldSet extensionFieldSets[] = 5; - } - - request struct RemoveSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - } - - response struct RemoveSceneResponse = 2 { - status status = 0; - group_id groupID = 1; - int8u sceneID = 2; - } - - request struct RemoveAllScenesRequest { - group_id groupID = 0; - } - - response struct RemoveAllScenesResponse = 3 { - status status = 0; - group_id groupID = 1; - } - - request struct StoreSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - } - - response struct StoreSceneResponse = 4 { - status status = 0; - group_id groupID = 1; - int8u sceneID = 2; - } - - request struct RecallSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - optional nullable int16u transitionTime = 2; - } - - request struct GetSceneMembershipRequest { - group_id groupID = 0; - } - - response struct GetSceneMembershipResponse = 6 { - status status = 0; - nullable int8u capacity = 1; - group_id groupID = 2; - optional int8u sceneList[] = 3; - } - - request struct EnhancedAddSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - int16u transitionTime = 2; - char_string sceneName = 3; - ExtensionFieldSet extensionFieldSets[] = 4; - } - - response struct EnhancedAddSceneResponse = 64 { - status status = 0; - group_id groupID = 1; - int8u sceneID = 2; - } - - request struct EnhancedViewSceneRequest { - group_id groupID = 0; - int8u sceneID = 1; - } - - response struct EnhancedViewSceneResponse = 65 { - status status = 0; - group_id groupID = 1; - int8u sceneID = 2; - optional int16u transitionTime = 3; - optional char_string sceneName = 4; - optional ExtensionFieldSet extensionFieldSets[] = 5; - } - - request struct CopySceneRequest { - CopyModeBitmap mode = 0; - group_id groupIdentifierFrom = 1; - int8u sceneIdentifierFrom = 2; - group_id groupIdentifierTo = 3; - int8u sceneIdentifierTo = 4; - } - - response struct CopySceneResponse = 66 { - status status = 0; - group_id groupIdentifierFrom = 1; - int8u sceneIdentifierFrom = 2; - } - - /** Add a scene to the scene table. Extension field sets are supported, and are inputed as '{"ClusterID": VALUE, "AttributeValueList":[{"AttributeId": VALUE, "AttributeValue": VALUE}]}' */ - fabric command access(invoke: manage) AddScene(AddSceneRequest): AddSceneResponse = 0; - /** Retrieves the requested scene entry from its Scene table. */ - fabric command ViewScene(ViewSceneRequest): ViewSceneResponse = 1; - /** Removes the requested scene entry, corresponding to the value of the GroupID field, from its Scene Table */ - fabric command access(invoke: manage) RemoveScene(RemoveSceneRequest): RemoveSceneResponse = 2; - /** Remove all scenes, corresponding to the value of the GroupID field, from its Scene Table */ - fabric command access(invoke: manage) RemoveAllScenes(RemoveAllScenesRequest): RemoveAllScenesResponse = 3; - /** Adds the scene entry into its Scene Table along with all extension field sets corresponding to the current state of other clusters on the same endpoint */ - fabric command access(invoke: manage) StoreScene(StoreSceneRequest): StoreSceneResponse = 4; - /** Set the attributes and corresponding state for each other cluster implemented on the endpoint accordingly to the resquested scene entry in the Scene Table */ - fabric command RecallScene(RecallSceneRequest): DefaultSuccess = 5; - /** Get an unused scene identifier when no commissioning tool is in the network, or for a commissioning tool to get the used scene identifiers within a certain group */ - fabric command GetSceneMembership(GetSceneMembershipRequest): GetSceneMembershipResponse = 6; - /** Allows a scene to be added using a finer scene transition time than the AddScene command. */ - fabric command EnhancedAddScene(EnhancedAddSceneRequest): EnhancedAddSceneResponse = 64; - /** Allows a scene to be retrieved using a finer scene transition time than the ViewScene command */ - fabric command EnhancedViewScene(EnhancedViewSceneRequest): EnhancedViewSceneResponse = 65; - /** Allows a client to efficiently copy scenes from one group/scene identifier pair to another group/scene identifier pair. */ - fabric command CopyScene(CopySceneRequest): CopySceneResponse = 66; -} - /** Attributes and commands for switching devices between 'On' and 'Off' states. */ cluster OnOff = 6 { revision 6; @@ -2488,7 +2295,6 @@ endpoint 1 { device type ma_onofflightswitch = 259, version 1; binding cluster Identify; - binding cluster Scenes; binding cluster OnOff; binding cluster ColorControl; diff --git a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter index 06285dfbaebaa7..8fa6b50f6c87e7 100644 --- a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter +++ b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter @@ -1536,6 +1536,16 @@ cluster Thermostat = 513 { kCoolingAndHeatingWithReheat = 5; } + enum PresetScenarioEnum : enum8 { + kUnspecified = 0; + kOccupied = 1; + kUnoccupied = 2; + kSleep = 3; + kWake = 4; + kVacation = 5; + kUserDefined = 6; + } + enum SetpointChangeSourceEnum : enum8 { kManual = 0; kSchedule = 1; @@ -1597,6 +1607,10 @@ cluster Thermostat = 513 { kSetback = 0x10; kAutoMode = 0x20; kLocalTemperatureNotExposed = 0x40; + kMatterScheduleConfiguration = 0x80; + kPresets = 0x100; + kSetpoints = 0x200; + kQueuedPresetsSupported = 0x400; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1606,6 +1620,11 @@ cluster Thermostat = 513 { kHeatingUsesFuel = 0x20; } + bitmap PresetTypeFeaturesBitmap : bitmap16 { + kAutomatic = 0x1; + kSupportsNames = 0x2; + } + bitmap ProgrammingOperationModeBitmap : bitmap8 { kScheduleActive = 0x1; kAutoRecovery = 0x2; @@ -1644,6 +1663,62 @@ cluster Thermostat = 513 { kCoolSetpointPresent = 0x2; } + bitmap ScheduleTypeFeaturesBitmap : bitmap16 { + kSupportsPresets = 0x1; + kSupportsSetpoints = 0x2; + kSupportsNames = 0x4; + kSupportsOff = 0x8; + } + + bitmap TemperatureSetpointHoldPolicyBitmap : bitmap8 { + kHoldDurationElapsed = 0x1; + kHoldDurationElapsedOrPresetChanged = 0x2; + } + + struct ScheduleTransitionStruct { + ScheduleDayOfWeekBitmap dayOfWeek = 0; + int16u transitionTime = 1; + optional octet_string<16> presetHandle = 2; + optional SystemModeEnum systemMode = 3; + optional temperature coolingSetpoint = 4; + optional temperature heatingSetpoint = 5; + } + + struct ScheduleStruct { + nullable octet_string<16> scheduleHandle = 0; + SystemModeEnum systemMode = 1; + optional char_string<64> name = 2; + optional octet_string<16> presetHandle = 3; + ScheduleTransitionStruct transitions[] = 4; + optional nullable boolean builtIn = 5; + } + + struct PresetStruct { + nullable octet_string<16> presetHandle = 0; + PresetScenarioEnum presetScenario = 1; + optional nullable char_string<64> name = 2; + optional temperature coolingSetpoint = 3; + optional temperature heatingSetpoint = 4; + nullable boolean builtIn = 5; + } + + struct PresetTypeStruct { + PresetScenarioEnum presetScenario = 0; + int8u numberOfPresets = 1; + PresetTypeFeaturesBitmap presetTypeFeatures = 2; + } + + struct QueuedPresetStruct { + nullable octet_string<16> presetHandle = 0; + nullable epoch_s transitionTimestamp = 1; + } + + struct ScheduleTypeStruct { + SystemModeEnum systemMode = 0; + int8u numberOfSchedules = 1; + ScheduleTypeFeaturesBitmap scheduleTypeFeatures = 2; + } + struct WeeklyScheduleTransitionStruct { int16u transitionTime = 0; nullable temperature heatSetpoint = 1; @@ -1699,6 +1774,20 @@ cluster Thermostat = 513 { attribute access(write: manage) optional ACLouverPositionEnum ACLouverPosition = 69; readonly attribute optional nullable temperature ACCoilTemperature = 70; attribute access(write: manage) optional ACCapacityFormatEnum ACCapacityformat = 71; + readonly attribute optional PresetTypeStruct presetTypes[] = 72; + readonly attribute optional ScheduleTypeStruct scheduleTypes[] = 73; + readonly attribute optional int8u numberOfPresets = 74; + readonly attribute optional int8u numberOfSchedules = 75; + readonly attribute optional int8u numberOfScheduleTransitions = 76; + readonly attribute optional nullable int8u numberOfScheduleTransitionPerDay = 77; + readonly attribute optional nullable octet_string<16> activePresetHandle = 78; + readonly attribute optional nullable octet_string<16> activeScheduleHandle = 79; + attribute access(write: manage) optional PresetStruct presets[] = 80; + attribute access(write: manage) optional ScheduleStruct schedules[] = 81; + readonly attribute optional boolean presetsSchedulesEditable = 82; + readonly attribute optional TemperatureSetpointHoldPolicyBitmap temperatureSetpointHoldPolicy = 83; + readonly attribute optional nullable epoch_s setpointHoldExpiryTimestamp = 84; + readonly attribute optional nullable QueuedPresetStruct queuedPreset = 85; readonly attribute command_id generatedCommandList[] = 65528; readonly attribute command_id acceptedCommandList[] = 65529; readonly attribute event_id eventList[] = 65530; @@ -1730,14 +1819,45 @@ cluster Thermostat = 513 { ScheduleModeBitmap modeToReturn = 1; } + request struct SetActiveScheduleRequestRequest { + octet_string<16> scheduleHandle = 0; + } + + request struct SetActivePresetRequestRequest { + octet_string<16> presetHandle = 0; + optional int16u delayMinutes = 1; + } + + request struct StartPresetsSchedulesEditRequestRequest { + int16u timeoutSeconds = 0; + } + + request struct SetTemperatureSetpointHoldPolicyRequest { + TemperatureSetpointHoldPolicyBitmap temperatureSetpointHoldPolicy = 0; + } + /** Command description for SetpointRaiseLower */ command SetpointRaiseLower(SetpointRaiseLowerRequest): DefaultSuccess = 0; /** Command description for SetWeeklySchedule */ command access(invoke: manage) SetWeeklySchedule(SetWeeklyScheduleRequest): DefaultSuccess = 1; /** Command description for GetWeeklySchedule */ command GetWeeklySchedule(GetWeeklyScheduleRequest): GetWeeklyScheduleResponse = 2; - /** The Clear Weekly Schedule command is used to clear the weekly schedule. */ + /** This command is used to clear the weekly schedule. The ClearWeeklySchedule command has no payload. */ command access(invoke: manage) ClearWeeklySchedule(): DefaultSuccess = 3; + /** This command is used to set the active schedule. */ + command SetActiveScheduleRequest(SetActiveScheduleRequestRequest): DefaultSuccess = 5; + /** This command is used to set the active preset. */ + command SetActivePresetRequest(SetActivePresetRequestRequest): DefaultSuccess = 6; + /** This command is used to start editing the presets and schedules. */ + command access(invoke: manage) StartPresetsSchedulesEditRequest(StartPresetsSchedulesEditRequestRequest): DefaultSuccess = 7; + /** This command is used to cancel editing presets and schedules. */ + command access(invoke: manage) CancelPresetsSchedulesEditRequest(): DefaultSuccess = 8; + /** This command is used to notify the server that all edits are done and should be committed. */ + command access(invoke: manage) CommitPresetsSchedulesRequest(): DefaultSuccess = 9; + /** This command is sent to cancel a queued preset. */ + command access(invoke: manage) CancelSetActivePresetRequest(): DefaultSuccess = 10; + /** This command sets the set point hold policy. */ + command SetTemperatureSetpointHoldPolicy(SetTemperatureSetpointHoldPolicyRequest): DefaultSuccess = 11; } /** An interface for configuring the user interface of a thermostat (which may be remote from the thermostat). */ diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 9c1c09406ad207..4b960749772d23 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -212,139 +212,6 @@ } ] }, - { - "name": "Scenes Management", - "code": 98, - "mfgCode": null, - "define": "SCENES_CLUSTER", - "side": "client", - "enabled": 1, - "apiMaturity": "provisional", - "commands": [ - { - "name": "AddScene", - "code": 0, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "AddSceneResponse", - "code": 0, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "ViewScene", - "code": 1, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "ViewSceneResponse", - "code": 1, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "RemoveScene", - "code": 2, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RemoveSceneResponse", - "code": 2, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "RemoveAllScenes", - "code": 3, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "RemoveAllScenesResponse", - "code": 3, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "StoreScene", - "code": 4, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "StoreSceneResponse", - "code": 4, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - }, - { - "name": "RecallScene", - "code": 5, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "GetSceneMembership", - "code": 6, - "mfgCode": null, - "source": "client", - "isIncoming": 0, - "isEnabled": 1 - }, - { - "name": "GetSceneMembershipResponse", - "code": 6, - "mfgCode": null, - "source": "server", - "isIncoming": 1, - "isEnabled": 1 - } - ], - "attributes": [ - { - "name": "ClusterRevision", - "code": 65533, - "mfgCode": null, - "side": "client", - "type": "int16u", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "5", - "reportable": 1, - "minInterval": 0, - "maxInterval": 65344, - "reportableChange": 0 - } - ] - }, { "name": "On/Off", "code": 6, @@ -3040,6 +2907,139 @@ } ] }, + { + "name": "Scenes Management", + "code": 98, + "mfgCode": null, + "define": "SCENES_CLUSTER", + "side": "client", + "enabled": 1, + "apiMaturity": "provisional", + "commands": [ + { + "name": "AddScene", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "AddSceneResponse", + "code": 0, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "ViewScene", + "code": 1, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "ViewSceneResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveScene", + "code": 2, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RemoveSceneResponse", + "code": 2, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RemoveAllScenes", + "code": 3, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "RemoveAllScenesResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "StoreScene", + "code": 4, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "StoreSceneResponse", + "code": 4, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + }, + { + "name": "RecallScene", + "code": 5, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "GetSceneMembership", + "code": 6, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + }, + { + "name": "GetSceneMembershipResponse", + "code": 6, + "mfgCode": null, + "source": "server", + "isIncoming": 1, + "isEnabled": 1 + } + ], + "attributes": [ + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "5", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, { "name": "HEPA Filter Monitoring", "code": 113, @@ -3140,7 +3140,7 @@ "side": "client", "type": "bitmap32", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "0", @@ -3201,7 +3201,7 @@ "side": "client", "type": "bitmap32", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "0", From a45e29fb88211d908b56b92179739e2b4151af94 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Wed, 17 Jan 2024 20:05:00 -0600 Subject: [PATCH 24/26] removing hard coded array size --- .../include/oven-operational-state-delegate.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index f3313030ac7ba4..201287c680c2bc 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -33,11 +33,11 @@ namespace OvenCavityOperationalState { class OvenCavityOperationalStateDelegate : public OperationalState::Delegate { private: - const Clusters::OperationalState::GenericOperationalState mOperationalStateList[8] = { + const Clusters::OperationalState::GenericOperationalState mOperationalStateList[] = { OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kStopped)), OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kRunning)), OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kPaused)), - OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kError)), + OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kError)) }; public: From cae8920b394014da95032be748ee7efe1ca82c58 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Wed, 17 Jan 2024 20:31:49 -0600 Subject: [PATCH 25/26] fixed compiler error --- .../include/oven-operational-state-delegate.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h index 201287c680c2bc..6d7338214f77ae 100644 --- a/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h +++ b/examples/all-clusters-app/all-clusters-common/include/oven-operational-state-delegate.h @@ -33,7 +33,7 @@ namespace OvenCavityOperationalState { class OvenCavityOperationalStateDelegate : public OperationalState::Delegate { private: - const Clusters::OperationalState::GenericOperationalState mOperationalStateList[] = { + inline static const Clusters::OperationalState::GenericOperationalState mOperationalStateList[] = { OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kStopped)), OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kRunning)), OperationalState::GenericOperationalState(to_underlying(OperationalState::OperationalStateEnum::kPaused)), From f744f17889c9025a474b22a7c3699657cf5afd57 Mon Sep 17 00:00:00 2001 From: Erik Hove Date: Thu, 18 Jan 2024 09:25:04 -0600 Subject: [PATCH 26/26] cleaned all-clusters zap --- .../all-clusters-app.matter | 67 ++++++++ .../all-clusters-common/all-clusters-app.zap | 151 +++++++++++++++++- 2 files changed, 212 insertions(+), 6 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index abb2f07a84e93f..44a73c84cca744 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -2658,6 +2658,62 @@ provisional cluster OvenCavityOperationalState = 72 { command Resume(): OperationalCommandResponse = 3; } +/** Attributes and commands for selecting a mode from a list of supported options. */ +provisional cluster OvenMode = 73 { + revision 1; + + enum ModeTag : enum16 { + kBake = 16384; + kConvection = 16385; + kGrill = 16386; + kRoast = 16387; + kClean = 16388; + kConvectionBake = 16389; + kConvectionRoast = 16390; + kWarming = 16391; + kProofing = 16392; + } + + bitmap Feature : bitmap32 { + kOnOff = 0x1; + } + + struct ModeTagStruct { + optional vendor_id mfgCode = 0; + enum16 value = 1; + } + + struct ModeOptionStruct { + char_string<64> label = 0; + int8u mode = 1; + ModeTagStruct modeTags[] = 2; + } + + readonly attribute ModeOptionStruct supportedModes[] = 0; + readonly attribute int8u currentMode = 1; + attribute optional nullable int8u startUpMode = 2; + attribute optional nullable int8u onMode = 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 ChangeToModeRequest { + int8u newMode = 0; + } + + response struct ChangeToModeResponse = 1 { + enum8 status = 0; + optional char_string statusText = 1; + } + + /** This command is used to change device modes. + On receipt of this command the device SHALL respond with a ChangeToModeResponse command. */ + command ChangeToMode(ChangeToModeRequest): ChangeToModeResponse = 0; +} + /** This cluster supports remotely monitoring and controling the different typs of functionality available to a drying device, such as a laundry dryer. */ cluster LaundryDryerControls = 74 { @@ -7554,6 +7610,17 @@ endpoint 1 { ram attribute clusterRevision default = 1; } + server cluster OvenMode { + callback attribute supportedModes; + ram attribute currentMode; + callback attribute generatedCommandList; + callback attribute acceptedCommandList; + callback attribute eventList; + callback attribute attributeList; + ram attribute featureMap default = 0; + ram attribute clusterRevision default = 1; + } + server cluster LaundryDryerControls { callback attribute supportedDrynessLevels; ram attribute selectedDrynessLevel; diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap index df67a9000b9d85..bd1802541c35e7 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap @@ -8150,7 +8150,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": null, + "defaultValue": "", "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8220,6 +8220,145 @@ "maxInterval": 65534, "reportableChange": 0 }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Oven Mode", + "code": 73, + "mfgCode": null, + "define": "OVEN_MODE_CLUSTER", + "side": "server", + "enabled": 1, + "apiMaturity": "provisional", + "attributes": [ + { + "name": "SupportedModes", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": null, + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "CurrentMode", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "int8u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, { "name": "GeneratedCommandList", "code": 65528, @@ -8336,7 +8475,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8368,7 +8507,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8384,7 +8523,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8400,7 +8539,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534, @@ -8416,7 +8555,7 @@ "storageOption": "External", "singleton": 0, "bounded": 0, - "defaultValue": "", + "defaultValue": null, "reportable": 1, "minInterval": 1, "maxInterval": 65534,