diff --git a/src/app/clusters/chime-server/chime-server.cpp b/src/app/clusters/chime-server/chime-server.cpp new file mode 100644 index 00000000000000..b2b2367f9b826f --- /dev/null +++ b/src/app/clusters/chime-server/chime-server.cpp @@ -0,0 +1,279 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/****************************************************************************' + * @file + * @brief Implementation for the Chime Server Cluster + ***************************************************************************/ + +#include "chime-server.h" + +#include +#include +#include +#include +#include + +using namespace chip; +using namespace chip::app; +using namespace chip::app::Clusters::Chime; +using namespace chip::app::Clusters::Chime::Attributes; +using chip::Protocols::InteractionModel::Status; +using ChimeSoundStructType = Structs::ChimeSoundStruct::Type; + +namespace chip { +namespace app { +namespace Clusters { + +ChimeServer::ChimeServer(EndpointId endpointId, ChimeDelegate & delegate) : + AttributeAccessInterface(MakeOptional(endpointId), Chime::Id), CommandHandlerInterface(MakeOptional(endpointId), Chime::Id), + mDelegate(delegate), mActiveChimeID(0), mEnabled(true) +{ + mDelegate.SetChimeServer(this); +} + +ChimeServer::~ChimeServer() +{ + // null out the ref to us on the delegate + mDelegate.SetChimeServer(nullptr); + + // unregister + CommandHandlerInterfaceRegistry::Instance().UnregisterCommandHandler(this); + AttributeAccessInterfaceRegistry::Instance().Unregister(this); +} + +CHIP_ERROR ChimeServer::Init() +{ + LoadPersistentAttributes(); + + VerifyOrReturnError(AttributeAccessInterfaceRegistry::Instance().Register(this), CHIP_ERROR_INTERNAL); + ReturnErrorOnFailure(CommandHandlerInterfaceRegistry::Instance().RegisterCommandHandler(this)); + return CHIP_NO_ERROR; +} + +void ChimeServer::LoadPersistentAttributes() +{ + // Load Active Chime ID + uint8_t storedActiveChimeID; + CHIP_ERROR err = GetSafeAttributePersistenceProvider()->ReadScalarValue( + ConcreteAttributePath(GetEndpointId(), Chime::Id, ActiveChimeID::Id), storedActiveChimeID); + if (err == CHIP_NO_ERROR) + { + mActiveChimeID = storedActiveChimeID; + } + else + { + // otherwise defaults + ChipLogDetail(Zcl, "Chime: Unable to load the ActiveChimeID attribute from the KVS. Defaulting to %u", mActiveChimeID); + } + + // Load Enabled + bool storedEnabled; + err = GetSafeAttributePersistenceProvider()->ReadScalarValue(ConcreteAttributePath(GetEndpointId(), Chime::Id, Enabled::Id), + storedEnabled); + if (err == CHIP_NO_ERROR) + { + mEnabled = storedEnabled; + } + else + { + // otherwise take the default + ChipLogDetail(Zcl, "Chime: Unable to load the Enabled attribute from the KVS. Defaulting to %u", mEnabled); + } +} + +// AttributeAccessInterface +CHIP_ERROR ChimeServer::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) +{ + VerifyOrDie(aPath.mClusterId == Chime::Id); + + switch (aPath.mAttributeId) + { + case ActiveChimeID::Id: + ReturnErrorOnFailure(aEncoder.Encode(mActiveChimeID)); + break; + case Enabled::Id: + ReturnErrorOnFailure(aEncoder.Encode(mEnabled)); + break; + case InstalledChimeSounds::Id: + ChimeServer * cs = this; + CHIP_ERROR err = + aEncoder.EncodeList([cs](const auto & encoder) -> CHIP_ERROR { return cs->EncodeSupportedChimeSounds(encoder); }); + return err; + } + + return CHIP_NO_ERROR; +} + +uint8_t ChimeServer::GetActiveChimeID() const +{ + return mActiveChimeID; +} + +bool ChimeServer::GetEnabled() const +{ + return mEnabled; +} + +// helper method to get the Chime Sounds one by one and encode into a list +CHIP_ERROR ChimeServer::EncodeSupportedChimeSounds(const AttributeValueEncoder::ListEncodeHelper & encoder) +{ + + for (uint8_t i = 0; true; i++) + { + ChimeSoundStructType chimeSound; + + // Get the chime sound + // We pass in a MutableCharSpan to avoid any ownership issues - Delegate needs to use + // CopyCharSpanToMutableCharSpan to copy data in + char buffer[kMaxChimeSoundNameSize]; + MutableCharSpan name(buffer); + auto err = mDelegate.GetChimeSoundByIndex(i, chimeSound.chimeID, name); + + // return if we've run off the end of the Chime Sound List on the delegate + if (err == CHIP_ERROR_PROVIDER_LIST_EXHAUSTED) + { + return CHIP_NO_ERROR; + } + + ReturnErrorOnFailure(err); + + // set the name on the struct + chimeSound.name = name; + + // and now encode the struct + ReturnErrorOnFailure(encoder.Encode(chimeSound)); + } + return CHIP_NO_ERROR; +} + +// helper method to check if the chimeID param is supported by the delegate +bool ChimeServer::IsSupportedChimeID(uint8_t chimeID) +{ + uint8_t supportedChimeID; + for (uint8_t i = 0; mDelegate.GetChimeIDByIndex(i, supportedChimeID) != CHIP_ERROR_PROVIDER_LIST_EXHAUSTED; i++) + { + if (supportedChimeID == chimeID) + { + return true; + } + } + + ChipLogDetail(Zcl, "Cannot find a supported ChimeID with value %u", chimeID); + return false; +} + +CHIP_ERROR ChimeServer::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) +{ + VerifyOrDie(aPath.mClusterId == Chime::Id); + Status status; + + switch (aPath.mAttributeId) + { + case ActiveChimeID::Id: { + uint8_t newValue; + ReturnErrorOnFailure(aDecoder.Decode(newValue)); + status = SetActiveChimeID(newValue); + return StatusIB(status).ToChipError(); + } + case Enabled::Id: { + bool newValue; + ReturnErrorOnFailure(aDecoder.Decode(newValue)); + status = SetEnabled(newValue); + return StatusIB(status).ToChipError(); + } + + default: + // Unknown attribute + return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute); + } +} + +Status ChimeServer::SetActiveChimeID(uint8_t chimeID) +{ + if (!IsSupportedChimeID(chimeID)) + { + return Protocols::InteractionModel::Status::ConstraintError; + } + + bool activeIDChanged = !(mActiveChimeID == chimeID); + if (activeIDChanged) + { + mActiveChimeID = chimeID; + + // Write new value to persistent storage. + auto endpointId = GetEndpointId(); + ConcreteAttributePath path = ConcreteAttributePath(endpointId, Chime::Id, ActiveChimeID::Id); + GetSafeAttributePersistenceProvider()->WriteScalarValue(path, mActiveChimeID); + + // and mark as dirty + MatterReportingAttributeChangeCallback(path); + } + return Protocols::InteractionModel::Status::Success; +} + +Status ChimeServer::SetEnabled(bool Enabled) +{ + bool enableChanged = !(mEnabled == Enabled); + + if (enableChanged) + { + mEnabled = Enabled; + + // Write new value to persistent storage. + auto endpointId = GetEndpointId(); + ConcreteAttributePath path = ConcreteAttributePath(endpointId, Chime::Id, Enabled::Id); + GetSafeAttributePersistenceProvider()->WriteScalarValue(path, mEnabled); + + // and mark as dirty + MatterReportingAttributeChangeCallback(path); + } + + return Protocols::InteractionModel::Status::Success; +} + +void ChimeServer::InvokeCommand(HandlerContext & ctx) +{ + switch (ctx.mRequestPath.mCommandId) + { + case Commands::PlayChimeSound::Id: + CommandHandlerInterface::HandleCommand( + ctx, [this](HandlerContext & ctx, const auto & req) { HandlePlayChimeSound(ctx, req); }); + break; + } +} + +void ChimeServer::HandlePlayChimeSound(HandlerContext & ctx, const Commands::PlayChimeSound::DecodableType & req) +{ + + ChipLogDetail(Zcl, "Chime: PlayChimeSound"); + + // call the delegate to play the chime + Status status = mDelegate.PlayChimeSound(); + ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); +} + +} // namespace Clusters +} // namespace app +} // namespace chip + +/** @brief Chime Cluster Server Init + * + * Server Init + * + */ +void MatterChimePluginServerInitCallback() {} diff --git a/src/app/clusters/chime-server/chime-server.h b/src/app/clusters/chime-server/chime-server.h new file mode 100644 index 00000000000000..7e98f741987219 --- /dev/null +++ b/src/app/clusters/chime-server/chime-server.h @@ -0,0 +1,178 @@ +/* + * + * Copyright (c) 2024 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Clusters { + +class ChimeDelegate; + +class ChimeServer : private AttributeAccessInterface, private CommandHandlerInterface +{ +public: + /** + * Creates a chime server instance. The Init() function needs to be called for this instance to be registered and + * called by the interaction model at the appropriate times. + * @param aEndpointId The endpoint on which this cluster exists. This must match the zap configuration. + * @param aDelegate A reference to the delegate to be used by this server. + * Note: the caller must ensure that the delegate lives throughout the instance's lifetime. + */ + ChimeServer(EndpointId endpointId, ChimeDelegate & delegate); + ~ChimeServer(); + + /** + * Initialise the chime server instance. + * @return Returns an error if the CommandHandler or AttributeHandler registration fails. + */ + CHIP_ERROR Init(); + + // Attribute Setters + /** + * Sets the ActiveChimeID attribute. Note, this also handles writing the new value into non-volatile storage. + * @param chimeSoundID The value to which the ActiveChimeID is to be set. + * @return Returns a ConstraintError if the chimeSoundID value is not valid. Returns Success otherwise. + */ + Protocols::InteractionModel::Status SetActiveChimeID(uint8_t chimeSoundID); + + /** + * Sets the Enabled attribute. Note, this also handles writing the new value into non-volatile storage. + * @param Enabled The value to which the Enabled is to be set. + */ + Protocols::InteractionModel::Status SetEnabled(bool Enabled); + + // Attribute Getters + /** + * @return The Current ActiveChimeID. + */ + uint8_t GetActiveChimeID() const; + + /** + * @return The Enabled attribute.. + */ + bool GetEnabled() const; + + /** + * @return The endpoint ID. + */ + EndpointId GetEndpointId() { return AttributeAccessInterface::GetEndpointId().Value(); } + + // Cluster constants from the spec + static constexpr uint8_t kMaxChimeSoundNameSize = 48; + + // List Change Reporting + /** + * Reports that the contents of the InstalledChimeSounds attribute have changed. + * The device SHALL call this method whenever it changes the list of installed chime sounds. + */ + void ReportInstalledChimeSoundsChange(); + +private: + ChimeDelegate & mDelegate; + + // Attribute local storage + uint8_t mActiveChimeID; + bool mEnabled; + + // AttributeAccessInterface + CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) override; + CHIP_ERROR Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) override; + + // CommandHandlerInterface + void InvokeCommand(HandlerContext & ctx) override; + void HandlePlayChimeSound(HandlerContext & ctx, const Chime::Commands::PlayChimeSound::DecodableType & req); + + // Helpers + // Loads all the persistent attributes from the KVS. + void LoadPersistentAttributes(); + + // Checks if the chimeID is supported by the delegate + bool IsSupportedChimeID(uint8_t chimeID); + + // Encodes all Installed Chime Sounds + CHIP_ERROR EncodeSupportedChimeSounds(const AttributeValueEncoder::ListEncodeHelper & encoder); +}; + +/** @brief + * Defines methods for implementing application-specific logic for the Chime Cluster. + */ +class ChimeDelegate +{ +public: + ChimeDelegate() = default; + + virtual ~ChimeDelegate() = default; + + /** + * Get the installed chime sounds. + * @param index The index of the chime sound to be returned. It is assumed that chime sounds are indexable from 0 and with no + * gaps. + * @param chimeID a reference to the uint8_t variable that is to contain the ChimeID value. + * @param name A reference to the mutable char span which will be mutated to receive the chime sound name on success. Use + * CopyCharSpanToMutableCharSpan to copy into the MutableCharSpan. + * @return Returns a CHIP_NO_ERROR if there was no error and the chime sound details were returned successfully, + * CHIP_ERROR_NOT_FOUND if the index in beyond the list of available chime sounds. + * + * Note: This is used by the SDK to populate the InstalledChimeSounds attribute. If the contents of this list change, + * the device SHALL call the Instance's ReportInstalledChimeSoundsChange method to report that this attribute has changed. + */ + virtual CHIP_ERROR GetChimeSoundByIndex(uint8_t chimeIndex, uint8_t & chimeID, MutableCharSpan & name) = 0; + + /** + * Get the installed chime sound IDs + * @param index The index of the chime ID to be returned. It is assumed that chime sounds are indexable from 0 and with no + * gaps. + * @param chimeID a reference to the uint8_t variable that is to contain the ChimeID value. + * @return Returns a CHIP_NO_ERROR if there was no error and the ChimeID was returned successfully, + * CHIP_ERROR_NOT_FOUND if the index in beyond the list of available chime sounds. + * + * Note: This is used by the SDK to help populate the InstalledChimeSounds attribute. If the contents of this list change, + * the device SHALL call the Instance's ReportInstalledChimeSoundsChange method to report that this attribute has changed. + */ + virtual CHIP_ERROR GetChimeIDByIndex(uint8_t chimeIndex, uint8_t & chimeID) = 0; + + // Commands + /** + * @brief Delegate should implement a handler to play the currently active chime sound. + * It should report Status::Success if successful and may + * return other Status codes if it fails + */ + virtual Protocols::InteractionModel::Status PlayChimeSound() = 0; + +protected: + friend class ChimeServer; + + ChimeServer * mChimeServer = nullptr; + + // sets the Chime Server pointer + void SetChimeServer(ChimeServer * chimeServer) { mChimeServer = chimeServer; } + ChimeServer * GetChimeServer() const { return mChimeServer; } +}; + +} // 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 61e7c45582268a..f5259748d9421c 100644 --- a/src/app/common/templates/config-data.yaml +++ b/src/app/common/templates/config-data.yaml @@ -36,6 +36,7 @@ CommandHandlerInterfaceOnlyClusters: - RVC Operational State - Sample MEI - Microwave Oven Control + - Chime - Energy EVSE - Energy EVSE Mode - Device Energy Management diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json index 0eba8fc692d6d8..39301cdc30cecc 100644 --- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json +++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json @@ -196,6 +196,7 @@ "MaxPathsPerInvoke" ], "Bridged Device Basic Information": ["ProductAppearance"], + "Chime": ["ActiveChimeID", "Enabled"], "Descriptor": ["ClusterRevision", "FeatureMap"], "Device Energy Management": [ "ESAType", diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json index 6907cfea0eb19f..c2de6acabf2951 100644 --- a/src/app/zap-templates/zcl/zcl.json +++ b/src/app/zap-templates/zcl/zcl.json @@ -190,6 +190,7 @@ "MaxPathsPerInvoke" ], "Bridged Device Basic Information": ["ProductAppearance"], + "Chime": ["ActiveChimeID", "Enabled"], "Descriptor": ["ClusterRevision", "FeatureMap"], "Device Energy Management": [ "ESAType", diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json index e38e8809616f45..4de99f1b7aaf3d 100644 --- a/src/app/zap_cluster_list.json +++ b/src/app/zap_cluster_list.json @@ -171,7 +171,7 @@ "concentration-measurement-server" ], "CHANNEL_CLUSTER": ["channel-server"], - "CHIME_CLUSTER": [], + "CHIME_CLUSTER": ["chime-server"], "COLOR_CONTROL_CLUSTER": ["color-control-server"], "COMMISSIONER_CONTROL_CLUSTER": ["commissioner-control-server"], "COMMISSIONING_CLUSTER": [], diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 1a1f8539267101..8c1eba99077039 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -2955,6 +2955,25 @@ } ] }, + { + "name": "Chime", + "code": 1366, + "mfgCode": null, + "define": "CHIME_CLUSTER", + "side": "client", + "enabled": 1, + "apiMaturity": "provisional", + "commands": [ + { + "name": "PlayChimeSound", + "code": 0, + "mfgCode": null, + "source": "client", + "isIncoming": 0, + "isEnabled": 1 + } + ] + }, { "name": "Unit Testing", "code": 4294048773, 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 c23e0e252bbb99..a1caa8052ae71e 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 @@ -38730,98 +38730,6 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value) namespace Chime { namespace Attributes { -namespace ActiveChimeID { - -Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType temp; - uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); - Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Chime::Id, Id, readable, sizeof(temp)); - VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status); - if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) - { - return Protocols::InteractionModel::Status::ConstraintError; - } - *value = Traits::StorageToWorking(temp); - return status; -} - -Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty) -{ - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) - { - return Protocols::InteractionModel::Status::ConstraintError; - } - Traits::StorageType storageValue; - Traits::WorkingToStorage(value, storageValue); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Chime::Id, Id), - EmberAfWriteDataInput(writable, ZCL_INT8U_ATTRIBUTE_TYPE).SetMarkDirty(markDirty)); -} - -Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value) -{ - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) - { - return Protocols::InteractionModel::Status::ConstraintError; - } - Traits::StorageType storageValue; - Traits::WorkingToStorage(value, storageValue); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteAttribute(endpoint, Clusters::Chime::Id, Id, writable, ZCL_INT8U_ATTRIBUTE_TYPE); -} - -} // namespace ActiveChimeID - -namespace Enabled { - -Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value) -{ - using Traits = NumericAttributeTraits; - Traits::StorageType temp; - uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); - Protocols::InteractionModel::Status status = emberAfReadAttribute(endpoint, Clusters::Chime::Id, Id, readable, sizeof(temp)); - VerifyOrReturnError(Protocols::InteractionModel::Status::Success == status, status); - if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) - { - return Protocols::InteractionModel::Status::ConstraintError; - } - *value = Traits::StorageToWorking(temp); - return status; -} - -Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty) -{ - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) - { - return Protocols::InteractionModel::Status::ConstraintError; - } - Traits::StorageType storageValue; - Traits::WorkingToStorage(value, storageValue); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteAttribute(ConcreteAttributePath(endpoint, Clusters::Chime::Id, Id), - EmberAfWriteDataInput(writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE).SetMarkDirty(markDirty)); -} - -Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value) -{ - using Traits = NumericAttributeTraits; - if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) - { - return Protocols::InteractionModel::Status::ConstraintError; - } - Traits::StorageType storageValue; - Traits::WorkingToStorage(value, storageValue); - uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); - return emberAfWriteAttribute(endpoint, Clusters::Chime::Id, Id, writable, ZCL_BOOLEAN_ATTRIBUTE_TYPE); -} - -} // namespace Enabled - namespace FeatureMap { Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value) 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 11e2228564e6ab..bb11fdf51607d1 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 @@ -5861,18 +5861,6 @@ Protocols::InteractionModel::Status Set(EndpointId endpoint, uint16_t value, Mar namespace Chime { namespace Attributes { -namespace ActiveChimeID { -Protocols::InteractionModel::Status Get(EndpointId endpoint, uint8_t * value); // int8u -Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value); -Protocols::InteractionModel::Status Set(EndpointId endpoint, uint8_t value, MarkAttributeDirty markDirty); -} // namespace ActiveChimeID - -namespace Enabled { -Protocols::InteractionModel::Status Get(EndpointId endpoint, bool * value); // boolean -Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value); -Protocols::InteractionModel::Status Set(EndpointId endpoint, bool value, MarkAttributeDirty markDirty); -} // namespace Enabled - namespace FeatureMap { Protocols::InteractionModel::Status Get(EndpointId endpoint, uint32_t * value); // bitmap32 Protocols::InteractionModel::Status Set(EndpointId endpoint, uint32_t value); 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 90be2632818072..430eb0bd3821fd 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -6930,12 +6930,6 @@ bool emberAfWebRTCTransportRequestorClusterICECandidateCallback( bool emberAfWebRTCTransportRequestorClusterEndCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::WebRTCTransportRequestor::Commands::End::DecodableType & commandData); -/** - * @brief Chime Cluster PlayChimeSound Command callback (from client) - */ -bool emberAfChimeClusterPlayChimeSoundCallback( - chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, - const chip::app::Clusters::Chime::Commands::PlayChimeSound::DecodableType & commandData); /** * @brief Commissioner Control Cluster RequestCommissioningApproval Command callback (from client) */