| /* |
| * |
| * 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 "core/BaseCluster.h" |
| #include "core/Endpoint.h" |
| |
| #include "lib/support/logging/CHIPLogging.h" |
| namespace matter { |
| namespace casting { |
| namespace core { |
| |
| template <typename TypeInfo> |
| using ReadResponseSuccessCallbackFn = std::function<void(void * context, chip::Optional<typename TypeInfo::DecodableType> before, |
| typename TypeInfo::DecodableArgType after)>; |
| using ReadResponseFailureCallbackFn = std::function<void(void * context, CHIP_ERROR err)>; |
| using WriteResponseSuccessCallbackFn = std::function<void(void * context)>; |
| using WriteResponseFailureCallbackFn = std::function<void(void * context, CHIP_ERROR err)>; |
| |
| template <typename TypeInfo> |
| struct ReadAttributeContext; |
| template <typename TypeInfo> |
| struct WriteAttributeContext; |
| template <typename TypeInfo> |
| struct SubscribeAttributeContext; |
| |
| template <typename TypeInfo> |
| class Attribute |
| { |
| private: |
| bool hasValue = false; |
| typename TypeInfo::DecodableType value; |
| |
| protected: |
| memory::Weak<core::Endpoint> GetEndpoint() const { return mEndpoint.lock(); } |
| memory::Weak<core::Endpoint> mEndpoint; |
| |
| public: |
| Attribute(memory::Weak<core::Endpoint> endpoint) { this->mEndpoint = endpoint; } |
| |
| ~Attribute() {} |
| |
| Attribute() = delete; |
| Attribute(Attribute & other) = delete; |
| void operator=(const Attribute &) = delete; |
| |
| chip::Optional<typename TypeInfo::DecodableType> GetValue() |
| { |
| return hasValue ? chip::MakeOptional(value) : chip::NullOptional; |
| } |
| |
| /** |
| * @brief Reads the value of the Attribute that belongs to the associated Endpoint and corresponding Cluster |
| * @param context current context passed back in successCb/FailureCb |
| * @param successCb Called when the Attribute is read successfully, with the value of the attribute after reading, as well as |
| * before (if the Attribute had been previously read) |
| * @param failureCb Called when there is a failure in reading the Attribute |
| */ |
| void Read(void * context, ReadResponseSuccessCallbackFn<TypeInfo> successCb, ReadResponseFailureCallbackFn failureCb) |
| { |
| memory::Strong<core::Endpoint> endpoint = this->GetEndpoint().lock(); |
| if (endpoint) |
| { |
| ReadAttributeContext<TypeInfo> * attributeContext = |
| new ReadAttributeContext<TypeInfo>(this, endpoint, context, successCb, failureCb); |
| |
| endpoint->GetCastingPlayer()->FindOrEstablishSession( |
| attributeContext, |
| // FindOrEstablishSession success handler |
| [](void * _context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle) { |
| ReadAttributeContext<TypeInfo> * _attributeContext = static_cast<ReadAttributeContext<TypeInfo> *>(_context); |
| ChipLogProgress(AppServer, "<Attribute>::Read() Found or established session"); |
| |
| // Read attribute |
| MediaClusterBase mediaClusterBase(exchangeMgr, sessionHandle, _attributeContext->mEndpoint->GetId()); |
| CHIP_ERROR err = mediaClusterBase.template ReadAttribute<TypeInfo>( |
| _attributeContext, |
| // Read success handler |
| [](void * __context, typename TypeInfo::DecodableArgType response) { |
| ReadAttributeContext<TypeInfo> * __attributeContext = |
| static_cast<ReadAttributeContext<TypeInfo> *>(__context); |
| ChipLogProgress(AppServer, "<Attribute>::Read() success"); |
| Attribute<TypeInfo> * __attr = static_cast<Attribute<TypeInfo> *>(__attributeContext->mAttribute); |
| if (__attr->hasValue) |
| { |
| typename TypeInfo::DecodableType prevValue = __attr->value; |
| __attr->value = response; |
| __attributeContext->mSuccessCb(__attributeContext->mClientContext, chip::MakeOptional(prevValue), |
| __attr->value); |
| } |
| else |
| { |
| __attr->hasValue = true; |
| __attr->value = response; |
| __attributeContext->mSuccessCb(__attributeContext->mClientContext, chip::NullOptional, |
| __attr->value); |
| } |
| delete __attributeContext; |
| }, |
| // Read failure handler |
| [](void * __context, CHIP_ERROR error) { |
| ReadAttributeContext<TypeInfo> * __attributeContext = |
| static_cast<ReadAttributeContext<TypeInfo> *>(__context); |
| ChipLogError(AppServer, |
| "<Attribute>::Read() failure response on EndpointId: %d with error: " |
| "%" CHIP_ERROR_FORMAT, |
| __attributeContext->mEndpoint->GetId(), error.Format()); |
| __attributeContext->mFailureCb(__attributeContext->mClientContext, error); |
| delete __attributeContext; |
| }); |
| |
| // error in reading the attribute |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(AppServer, |
| "<Attribute>::Read() failure in reading attribute on EndpointId: %d with error: " |
| "%" CHIP_ERROR_FORMAT, |
| _attributeContext->mEndpoint->GetId(), err.Format()); |
| _attributeContext->mFailureCb(_attributeContext->mClientContext, err); |
| delete _attributeContext; |
| } |
| }, |
| // FindOrEstablishSession failure handler |
| [](void * _context, const chip::ScopedNodeId & peerId, CHIP_ERROR error) { |
| ReadAttributeContext<TypeInfo> * _attributeContext = static_cast<ReadAttributeContext<TypeInfo> *>(_context); |
| ChipLogError(AppServer, |
| "<Attribute>::Read() failure in retrieving session info for peerId.nodeId: " |
| "0x" ChipLogFormatX64 ", peer.fabricIndex: %d with error: %" CHIP_ERROR_FORMAT, |
| ChipLogValueX64(peerId.GetNodeId()), peerId.GetFabricIndex(), error.Format()); |
| _attributeContext->mFailureCb(_attributeContext->mClientContext, error); |
| delete _attributeContext; |
| }); |
| } |
| else |
| { |
| ChipLogError(AppServer, "<Attribute>::Read() failure in retrieving Endpoint"); |
| failureCb(context, CHIP_ERROR_INCORRECT_STATE); |
| } |
| } |
| |
| /** |
| * @brief Writes the value of the Attribute to an associated Endpoint and corresponding Cluster |
| * |
| * @param requestData value of the Attribute to be written |
| * @param context current context passed back in successCb/FailureCb |
| * @param successCb Called when the Attribute is written successfully |
| * @param failureCb Called when there is a failure in writing the Attribute |
| * @param aTimedWriteTimeoutMs write timeout |
| */ |
| void Write(const typename TypeInfo::Type & requestData, void * context, WriteResponseSuccessCallbackFn successCb, |
| WriteResponseFailureCallbackFn failureCb, const chip::Optional<uint16_t> & aTimedWriteTimeoutMs) |
| { |
| memory::Strong<core::Endpoint> endpoint = this->GetEndpoint().lock(); |
| if (endpoint) |
| { |
| WriteAttributeContext<typename TypeInfo::Type> * attributeContext = new WriteAttributeContext<typename TypeInfo::Type>( |
| this, endpoint, requestData, context, successCb, failureCb, aTimedWriteTimeoutMs); |
| |
| endpoint->GetCastingPlayer()->FindOrEstablishSession( |
| attributeContext, |
| // FindOrEstablishSession success handler |
| [](void * _context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle) { |
| WriteAttributeContext<typename TypeInfo::Type> * _attributeContext = |
| static_cast<WriteAttributeContext<typename TypeInfo::Type> *>(_context); |
| ChipLogProgress(AppServer, "<Attribute>::Write() Found or established session"); |
| |
| // Write attribute |
| MediaClusterBase mediaClusterBase(exchangeMgr, sessionHandle, _attributeContext->mEndpoint->GetId()); |
| CHIP_ERROR err = mediaClusterBase.template WriteAttribute<TypeInfo>( |
| _attributeContext->mRequestData, _attributeContext, |
| // Write success handler |
| [](void * __context) { |
| WriteAttributeContext<typename TypeInfo::Type> * __attributeContext = |
| static_cast<WriteAttributeContext<typename TypeInfo::Type> *>(__context); |
| ChipLogProgress(AppServer, "<Attribute>::Write() success"); |
| __attributeContext->mSuccessCb(__attributeContext->mClientContext); |
| delete __attributeContext; |
| }, |
| // Write failure handler |
| [](void * __context, CHIP_ERROR error) { |
| WriteAttributeContext<typename TypeInfo::Type> * __attributeContext = |
| static_cast<WriteAttributeContext<typename TypeInfo::Type> *>(__context); |
| ChipLogError(AppServer, |
| "<Attribute>::Write() failure response on EndpointId: %d with error: " |
| "%" CHIP_ERROR_FORMAT, |
| __attributeContext->mEndpoint->GetId(), error.Format()); |
| __attributeContext->mFailureCb(__attributeContext->mClientContext, error); |
| delete __attributeContext; |
| }, |
| _attributeContext->mTimedWriteTimeoutMs); |
| |
| // error in writing to the attribute |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(AppServer, |
| "<Attribute>::Write() failure in reading attribute on EndpointId: %d with error: " |
| "%" CHIP_ERROR_FORMAT, |
| _attributeContext->mEndpoint->GetId(), err.Format()); |
| _attributeContext->mFailureCb(_attributeContext->mClientContext, err); |
| delete _attributeContext; |
| } |
| }, |
| // FindOrEstablishSession failure handler |
| [](void * _context, const chip::ScopedNodeId & peerId, CHIP_ERROR error) { |
| WriteAttributeContext<typename TypeInfo::Type> * _attributeContext = |
| static_cast<WriteAttributeContext<typename TypeInfo::Type> *>(_context); |
| ChipLogError(AppServer, |
| "<Attribute>::Write() failure in retrieving session info for peerId.nodeId: " |
| "0x" ChipLogFormatX64 ", peer.fabricIndex: %d with error: %" CHIP_ERROR_FORMAT, |
| ChipLogValueX64(peerId.GetNodeId()), peerId.GetFabricIndex(), error.Format()); |
| _attributeContext->mFailureCb(_attributeContext->mClientContext, error); |
| delete _attributeContext; |
| }); |
| } |
| else |
| { |
| ChipLogError(AppServer, "<Attribute>::Write() failure in retrieving Endpoint"); |
| failureCb(context, CHIP_ERROR_INCORRECT_STATE); |
| } |
| } |
| |
| /** |
| * @brief Subscribes to the value of the Attribute that belongs to the associated Endpoint and corresponding Cluster |
| * |
| * @param context current context passed back in successCb/FailureCb |
| * @param successCb Called when the Attribute is read successfully, with the value of the attribute after reading, as well as |
| * before (if the Attribute had been previously read) |
| * @param failureCb Called when there is a failure in reading the Attribute |
| * @param minIntervalFloorSeconds the requested minimum interval boundary floor in seconds for attribute udpates |
| * @param maxIntervalCeilingSeconds the requested maximum interval boundary ceiling in seconds for attribute udpates |
| */ |
| void Subscribe(void * context, ReadResponseSuccessCallbackFn<TypeInfo> successCb, ReadResponseFailureCallbackFn failureCb, |
| uint16_t minIntervalFloorSeconds, uint16_t maxIntervalCeilingSeconds) |
| { |
| memory::Strong<core::Endpoint> endpoint = this->GetEndpoint().lock(); |
| if (endpoint) |
| { |
| SubscribeAttributeContext<TypeInfo> * attributeContext = new SubscribeAttributeContext<TypeInfo>( |
| this, endpoint, context, successCb, failureCb, minIntervalFloorSeconds, maxIntervalCeilingSeconds); |
| |
| endpoint->GetCastingPlayer()->FindOrEstablishSession( |
| attributeContext, |
| // FindOrEstablishSession success handler |
| [](void * _context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle) { |
| SubscribeAttributeContext<TypeInfo> * _attributeContext = |
| static_cast<SubscribeAttributeContext<TypeInfo> *>(_context); |
| ChipLogProgress(AppServer, "<Attribute>::Subscribe() Found or established session"); |
| |
| // Subscribe to attribute |
| MediaClusterBase mediaClusterBase(exchangeMgr, sessionHandle, _attributeContext->mEndpoint->GetId()); |
| CHIP_ERROR err = mediaClusterBase.template SubscribeAttribute<TypeInfo>( |
| _attributeContext, |
| // Subscription success handler |
| [](void * __context, typename TypeInfo::DecodableArgType response) { |
| SubscribeAttributeContext<TypeInfo> * __attributeContext = |
| static_cast<SubscribeAttributeContext<TypeInfo> *>(__context); |
| ChipLogProgress(AppServer, "<Attribute>::Subscribe() success"); |
| Attribute<TypeInfo> * __attr = static_cast<Attribute<TypeInfo> *>(__attributeContext->mAttribute); |
| if (__attr->hasValue) |
| { |
| typename TypeInfo::DecodableType prevValue = __attr->value; |
| __attr->value = response; |
| __attributeContext->mSuccessCb(__attributeContext->mClientContext, chip::MakeOptional(prevValue), |
| __attr->value); |
| } |
| else |
| { |
| __attr->hasValue = true; |
| __attr->value = response; |
| __attributeContext->mSuccessCb(__attributeContext->mClientContext, chip::NullOptional, |
| __attr->value); |
| } |
| delete __attributeContext; |
| }, |
| // Subscription failure handler |
| [](void * __context, CHIP_ERROR error) { |
| SubscribeAttributeContext<TypeInfo> * __attributeContext = |
| static_cast<SubscribeAttributeContext<TypeInfo> *>(__context); |
| ChipLogError(AppServer, |
| "<Attribute>::Subscribe() failure response on EndpointId: %d with error: " |
| "%" CHIP_ERROR_FORMAT, |
| __attributeContext->mEndpoint->GetId(), error.Format()); |
| __attributeContext->mFailureCb(__attributeContext->mClientContext, error); |
| delete __attributeContext; |
| }, |
| _attributeContext->mMinIntervalFloorSeconds, _attributeContext->mMaxIntervalCeilingSeconds, |
| nullptr /* SubscriptionEstablishedCallback */, nullptr /* ResubscriptionAttemptCallback */, |
| true /* aIsFabricFiltered */, true /* aKeepPreviousSubscriptions */); |
| |
| // error in subscribing to the attribute |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(AppServer, |
| "<Attribute>::Subscribe() failure in reading attribute on EndpointId: %d with error: " |
| "%" CHIP_ERROR_FORMAT, |
| _attributeContext->mEndpoint->GetId(), err.Format()); |
| _attributeContext->mFailureCb(_attributeContext->mClientContext, err); |
| delete _attributeContext; |
| } |
| }, |
| // FindOrEstablishSession failure handler |
| [](void * _context, const chip::ScopedNodeId & peerId, CHIP_ERROR error) { |
| SubscribeAttributeContext<TypeInfo> * _attributeContext = |
| static_cast<SubscribeAttributeContext<TypeInfo> *>(_context); |
| ChipLogError(AppServer, |
| "<Attribute>::Subscribe() failure in retrieving session info for peerId.nodeId: " |
| "0x" ChipLogFormatX64 ", peer.fabricIndex: %d with error: %" CHIP_ERROR_FORMAT, |
| ChipLogValueX64(peerId.GetNodeId()), peerId.GetFabricIndex(), error.Format()); |
| _attributeContext->mFailureCb(_attributeContext->mClientContext, error); |
| delete _attributeContext; |
| }); |
| } |
| else |
| { |
| ChipLogError(AppServer, "<Attribute>::Subscribe() failure in retrieving Endpoint"); |
| failureCb(context, CHIP_ERROR_INCORRECT_STATE); |
| } |
| } |
| }; |
| |
| /** |
| * @brief Context object used by the Attribute class during the Read API's execution |
| */ |
| template <typename TypeInfo> |
| struct ReadAttributeContext |
| { |
| ReadAttributeContext(void * attribute, memory::Strong<core::Endpoint> endpoint, void * clientContext, |
| ReadResponseSuccessCallbackFn<TypeInfo> successCb, ReadResponseFailureCallbackFn failureCb) : |
| mEndpoint(endpoint), |
| mClientContext(clientContext), mSuccessCb(successCb), mFailureCb(failureCb) |
| { |
| mAttribute = attribute; |
| } |
| |
| void * mAttribute; |
| memory::Strong<core::Endpoint> mEndpoint; |
| void * mClientContext; |
| ReadResponseSuccessCallbackFn<TypeInfo> mSuccessCb; |
| ReadResponseFailureCallbackFn mFailureCb; |
| }; |
| |
| /** |
| * @brief Context object used by the Attribute class during the Write API's execution |
| */ |
| template <typename TypeInfoType> |
| struct WriteAttributeContext |
| { |
| WriteAttributeContext(memory::Strong<core::Endpoint> endpoint, const TypeInfoType & requestData, void * clientContext, |
| WriteResponseSuccessCallbackFn successCb, WriteResponseFailureCallbackFn failureCb, |
| const chip::Optional<uint16_t> & timedWriteTimeoutMs) : |
| mEndpoint(endpoint), |
| mClientContext(clientContext), mSuccessCb(successCb), mFailureCb(failureCb) |
| { |
| mRequestData = requestData; |
| mTimedWriteTimeoutMs = timedWriteTimeoutMs; |
| } |
| |
| memory::Strong<core::Endpoint> mEndpoint; |
| TypeInfoType mRequestData; |
| void * mClientContext; |
| WriteResponseSuccessCallbackFn mSuccessCb; |
| WriteResponseFailureCallbackFn mFailureCb; |
| chip::Optional<uint16_t> & mTimedWriteTimeoutMs; |
| }; |
| |
| /** |
| * @brief Context object used by the Attribute class during the Subscribe API's execution |
| */ |
| template <typename TypeInfo> |
| struct SubscribeAttributeContext |
| { |
| SubscribeAttributeContext(void * attribute, memory::Strong<core::Endpoint> endpoint, void * clientContext, |
| ReadResponseSuccessCallbackFn<TypeInfo> successCb, ReadResponseFailureCallbackFn failureCb, |
| uint16_t minIntervalFloorSeconds, uint16_t maxIntervalCeilingSeconds) : |
| mEndpoint(endpoint), |
| mClientContext(clientContext), mSuccessCb(successCb), mFailureCb(failureCb) |
| { |
| mAttribute = attribute; |
| mMinIntervalFloorSeconds = minIntervalFloorSeconds; |
| mMaxIntervalCeilingSeconds = maxIntervalCeilingSeconds; |
| } |
| |
| void * mAttribute; |
| memory::Strong<core::Endpoint> mEndpoint; |
| void * mClientContext; |
| ReadResponseSuccessCallbackFn<TypeInfo> mSuccessCb; |
| ReadResponseFailureCallbackFn mFailureCb; |
| uint16_t mMinIntervalFloorSeconds; |
| uint16_t mMaxIntervalCeilingSeconds; |
| }; |
| |
| }; // namespace core |
| }; // namespace casting |
| }; // namespace matter |
