Add a way to run custom cluster logic for attribute write (#11520)

* Add a way to run custom cluster logic for attribute write

* Address review comments

src/app/AttributeAccessInterface.h

@@ -20,6 +20,7 @@
 
 #include <app/ConcreteAttributePath.h>
 #include <app/MessageDef/AttributeDataIB.h>
+#include <app/data-model/Decode.h>
 #include <app/data-model/Encode.h>
 #include <app/data-model/List.h> // So we can encode lists
 #include <app/data-model/TagBoundEncoder.h>
@@ -101,6 +102,25 @@ class AttributeValueEncoder : protected TagBoundEncoder
  const FabricIndex mAccessingFabricIndex;
 };
 
+class AttributeValueDecoder
+{
+public:
+ AttributeValueDecoder(TLV::TLVReader & aReader) : mReader(aReader) {}
+
+ template <typename T>
+ CHIP_ERROR Decode(T & aArg)
+ {
+ mTriedDecode = true;
+ return DataModel::Decode(mReader, aArg);
+ }
+
+ bool TriedDecode() const { return mTriedDecode; }
+
+private:
+ TLV::TLVReader & mReader;
+ bool mTriedDecode = false;
+};
+
 class AttributeAccessInterface
 {
 public:
@@ -127,6 +147,20 @@ class AttributeAccessInterface
  */
  virtual CHIP_ERROR Read(const ConcreteAttributePath & aPath, AttributeValueEncoder & aEncoder) = 0;
 
+ /**
+ * Callback for writing attributes.
+ *
+ * @param [in] aPath indicates which exact data is being written.
+ * @param [in] aDecoder the AttributeValueDecoder to use for decoding the
+ * data. If this function returns scucess and no attempt is
+ * made to decode data using aDecoder, the
+ * AttributeAccessInterface did not try to write any data. In
+ * this case, normal attribute access will happen for the write.
+ * This may involve writing to the attribute store or external
+ * attribute callbacks.
+ */
+ virtual CHIP_ERROR Write(const ConcreteAttributePath & aPath, AttributeValueDecoder & aDecoder) { return CHIP_NO_ERROR; }
+
  /**
  * Mechanism for keeping track of a chain of AttributeAccessInterfaces.
  */

src/app/clusters/test-cluster-server/test-cluster-server.cpp

@@ -40,24 +40,51 @@ using namespace chip::app::Clusters::TestCluster;
 using namespace chip::app::Clusters::TestCluster::Commands;
 using namespace chip::app::Clusters::TestCluster::Attributes;
 
+// The number of elements in the test attribute list
+constexpr uint8_t kAttributeListLength = 4;
+
+// The maximum length of the test attribute list element in bytes
+constexpr uint8_t kAttributeEntryLength = 6;
+
 namespace {
 
+class OctetStringData
+{
+public:
+ uint8_t * Data() { return mDataBuf; }
+ size_t Length() const { return mDataLen; }
+ void SetLength(size_t size) { mDataLen = size; }
+
+private:
+ uint8_t mDataBuf[kAttributeEntryLength];
+ size_t mDataLen = 0;
+};
+
 class TestAttrAccess : public AttributeAccessInterface
 {
 public:
  // Register for the Test Cluster cluster on all endpoints.
  TestAttrAccess() : AttributeAccessInterface(Optional<EndpointId>::Missing(), TestCluster::Id) {}
 
  CHIP_ERROR Read(const ConcreteAttributePath & aPath, AttributeValueEncoder & aEncoder) override;
+ CHIP_ERROR Write(const ConcreteAttributePath & aPath, AttributeValueDecoder & aDecoder) override;
 
 private:
  CHIP_ERROR ReadListInt8uAttribute(AttributeValueEncoder & aEncoder);
+ CHIP_ERROR WriteListInt8uAttribute(AttributeValueDecoder & aDecoder);
  CHIP_ERROR ReadListOctetStringAttribute(AttributeValueEncoder & aEncoder);
+ CHIP_ERROR WriteListOctetStringAttribute(AttributeValueDecoder & aDecoder);
  CHIP_ERROR ReadListStructOctetStringAttribute(AttributeValueEncoder & aEncoder);
+ CHIP_ERROR WriteListStructOctetStringAttribute(AttributeValueDecoder & aDecoder);
  CHIP_ERROR ReadListNullablesAndOptionalsStructAttribute(AttributeValueEncoder & aEncoder);
+ CHIP_ERROR WriteListNullablesAndOptionalsStructAttribute(AttributeValueDecoder & aDecoder);
 };
 
 TestAttrAccess gAttrAccess;
+uint8_t gListUint8Data[kAttributeListLength];
+OctetStringData gListOctetStringData[kAttributeListLength];
+OctetStringData gListOperationalCert[kAttributeListLength];
+Structs::TestListStructOctet::Type listStructOctetStringData[kAttributeListLength];
 
 CHIP_ERROR TestAttrAccess::Read(const ConcreteAttributePath & aPath, AttributeValueEncoder & aEncoder)
 {
@@ -83,54 +110,140 @@ CHIP_ERROR TestAttrAccess::Read(const ConcreteAttributePath & aPath, AttributeVa
  return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR TestAttrAccess::Write(const ConcreteAttributePath & aPath, AttributeValueDecoder & aDecoder)
+{
+ switch (aPath.mAttributeId)
+ {
+ case ListInt8u::Id: {
+ return WriteListInt8uAttribute(aDecoder);
+ }
+ case ListOctetString::Id: {
+ return WriteListOctetStringAttribute(aDecoder);
+ }
+ case ListStructOctetString::Id: {
+ return WriteListStructOctetStringAttribute(aDecoder);
+ }
+ case ListNullablesAndOptionalsStruct::Id: {
+ return WriteListNullablesAndOptionalsStructAttribute(aDecoder);
+ }
+ default: {
+ break;
+ }
+ }
+
+ return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR TestAttrAccess::ReadListInt8uAttribute(AttributeValueEncoder & aEncoder)
 {
  return aEncoder.EncodeList([](const TagBoundEncoder & encoder) -> CHIP_ERROR {
- constexpr uint8_t maxValue = 4;
- for (uint8_t value = 1; value <= maxValue; value++)
+ for (uint8_t index = 0; index < kAttributeListLength; index++)
  {
- ReturnErrorOnFailure(encoder.Encode(value));
+ ReturnErrorOnFailure(encoder.Encode(gListUint8Data[index]));
  }
  return CHIP_NO_ERROR;
  });
 }
 
+CHIP_ERROR TestAttrAccess::WriteListInt8uAttribute(AttributeValueDecoder & aDecoder)
+{
+ ListInt8u::TypeInfo::DecodableType list;
+
+ ReturnErrorOnFailure(aDecoder.Decode(list));
+
+ uint8_t index = 0;
+ auto iter = list.begin();
+ while (iter.Next())
+ {
+ auto & entry = iter.GetValue();
+
+ VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL);
+ gListUint8Data[index++] = entry;
+ }
+
+ return iter.GetStatus();
+}
+
 CHIP_ERROR TestAttrAccess::ReadListOctetStringAttribute(AttributeValueEncoder & aEncoder)
 {
  return aEncoder.EncodeList([](const TagBoundEncoder & encoder) -> CHIP_ERROR {
- constexpr uint16_t attributeCount = 4;
- char data[6] = { 'T', 'e', 's', 't', 'N', '\0' };
-
- for (uint8_t index = 0; index < attributeCount; index++)
+ for (uint8_t index = 0; index < kAttributeListLength; index++)
  {
- snprintf(data + strlen(data) - 1, 2, "%d", index);
- ByteSpan span(Uint8::from_char(data), strlen(data));
+ ByteSpan span(gListOctetStringData[index].Data(), gListOctetStringData[index].Length());
  ReturnErrorOnFailure(encoder.Encode(span));
  }
  return CHIP_NO_ERROR;
  });
 }
 
+CHIP_ERROR TestAttrAccess::WriteListOctetStringAttribute(AttributeValueDecoder & aDecoder)
+{
+ ListOctetString::TypeInfo::DecodableType list;
+
+ ReturnErrorOnFailure(aDecoder.Decode(list));
+
+ uint8_t index = 0;
+ auto iter = list.begin();
+ while (iter.Next())
+ {
+ const auto & entry = iter.GetValue();
+
+ VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL);
+ VerifyOrReturnError(entry.size() <= kAttributeEntryLength, CHIP_ERROR_BUFFER_TOO_SMALL);
+ memcpy(gListOctetStringData[index].Data(), entry.data(), entry.size());
+ gListOctetStringData[index].SetLength(entry.size());
+ index++;
+ }
+
+ return iter.GetStatus();
+}
+
 CHIP_ERROR TestAttrAccess::ReadListStructOctetStringAttribute(AttributeValueEncoder & aEncoder)
 {
  return aEncoder.EncodeList([](const TagBoundEncoder & encoder) -> CHIP_ERROR {
- constexpr uint16_t attributeCount = 4;
- char data[6] = { 'T', 'e', 's', 't', 'N', '\0' };
-
- for (uint8_t index = 0; index < attributeCount; index++)
+ for (uint8_t index = 0; index < kAttributeListLength; index++)
  {
- snprintf(data + strlen(data) - 1, 2, "%d", index);
- ByteSpan span(Uint8::from_char(data), strlen(data));
-
  Structs::TestListStructOctet::Type structOctet;
- structOctet.fabricIndex = index;
- structOctet.operationalCert = span;
+ structOctet.fabricIndex = listStructOctetStringData[index].fabricIndex;
+ structOctet.operationalCert = listStructOctetStringData[index].operationalCert;
  ReturnErrorOnFailure(encoder.Encode(structOctet));
  }
+
  return CHIP_NO_ERROR;
  });
 }
 
+CHIP_ERROR TestAttrAccess::WriteListStructOctetStringAttribute(AttributeValueDecoder & aDecoder)
+{
+ ListStructOctetString::TypeInfo::DecodableType list;
+
+ ReturnErrorOnFailure(aDecoder.Decode(list));
+
+ uint8_t index = 0;
+ auto iter = list.begin();
+ while (iter.Next())
+ {
+ const auto & entry = iter.GetValue();
+
+ VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL);
+ VerifyOrReturnError(entry.operationalCert.size() <= kAttributeEntryLength, CHIP_ERROR_BUFFER_TOO_SMALL);
+ memcpy(gListOperationalCert[index].Data(), entry.operationalCert.data(), entry.operationalCert.size());
+ gListOperationalCert[index].SetLength(entry.operationalCert.size());
+
+ listStructOctetStringData[index].fabricIndex = entry.fabricIndex;
+ listStructOctetStringData[index].operationalCert =
+ ByteSpan(gListOperationalCert[index].Data(), gListOperationalCert[index].Length());
+ index++;
+ }
+
+ if (iter.GetStatus() != CHIP_NO_ERROR)
+ {
+ return CHIP_ERROR_INVALID_DATA_LIST;
+ }
+
+ return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR TestAttrAccess::ReadListNullablesAndOptionalsStructAttribute(AttributeValueEncoder & aEncoder)
 {
  return aEncoder.EncodeList([](const TagBoundEncoder & encoder) -> CHIP_ERROR {
@@ -142,6 +255,11 @@ CHIP_ERROR TestAttrAccess::ReadListNullablesAndOptionalsStructAttribute(Attribut
  });
 }
 
+CHIP_ERROR TestAttrAccess::WriteListNullablesAndOptionalsStructAttribute(AttributeValueDecoder & aDecoder)
+{
+ // TODO Add yaml test case for NullablesAndOptionalsStruct list
+ return CHIP_NO_ERROR;
+}
 } // namespace
 
 bool emberAfTestClusterClusterTestCallback(app::CommandHandler *, const app::ConcreteCommandPath & commandPath,

src/app/tests/suites/TestCluster.yaml

@@ -732,36 +732,6 @@ tests:
  arguments:
  value: ""
 
- # Tests for List attribute
-
- - label: "Read attribute LIST"
- command: "readAttribute"
- attribute: "list_int8u"
- response:
- value: [1, 2, 3, 4]
-
- # Tests for List Octet String attribute
-
- - label: "Read attribute LIST_OCTET_STRING"
- command: "readAttribute"
- attribute: "list_octet_string"
- response:
- value: ["Test0", "Test1", "Test2", "Test3"]
-
- # Tests for List Struct Octet String attribute
-
- - label: "Read attribute LIST_STRUCT_OCTET_STRING"
- command: "readAttribute"
- attribute: "list_struct_octet_string"
- response:
- value:
- [
- { fabricIndex: 0, operationalCert: "Test0" },
- { fabricIndex: 1, operationalCert: "Test1" },
- { fabricIndex: 2, operationalCert: "Test2" },
- { fabricIndex: 3, operationalCert: "Test3" },
- ]
-
  # Tests for Epoch Microseconds
 
  - label: "Read attribute EPOCH_US Default Value"

src/app/tests/suites/TestClusterComplexTypes.yaml

@@ -439,6 +439,55 @@ tests:
  - name: "value"
  value: false
 
+ - label:
+ "Write attribute LIST With List of INT8U and none of them is set to 0"
+ command: "writeAttribute"
+ attribute: "list_int8u"
+ arguments:
+ value: [1, 2, 3, 4]
+
+ - label: "Read attribute LIST With List of INT8U"
+ command: "readAttribute"
+ attribute: "list_int8u"
+ response:
+ value: [1, 2, 3, 4]
+
+ - label: "Write attribute LIST With List of OCTET_STRING"
+ command: "writeAttribute"
+ attribute: "list_octet_string"
+ arguments:
+ value: ["Test0", "Test1", "Test2", "Test3"]
+
+ - label: "Read attribute LIST With List of OCTET_STRING"
+ command: "readAttribute"
+ attribute: "list_octet_string"
+ response:
+ value: ["Test0", "Test1", "Test2", "Test3"]
+
+ - label: "Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"
+ command: "writeAttribute"
+ attribute: "list_struct_octet_string"
+ arguments:
+ value:
+ [
+ { fabricIndex: 0, operationalCert: "Test0" },
+ { fabricIndex: 1, operationalCert: "Test1" },
+ { fabricIndex: 2, operationalCert: "Test2" },
+ { fabricIndex: 3, operationalCert: "Test3" },
+ ]
+
+ - label: "Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"
+ command: "readAttribute"
+ attribute: "list_struct_octet_string"
+ response:
+ value:
+ [
+ { fabricIndex: 0, operationalCert: "Test0" },
+ { fabricIndex: 1, operationalCert: "Test1" },
+ { fabricIndex: 2, operationalCert: "Test2" },
+ { fabricIndex: 3, operationalCert: "Test3" },
+ ]
+
  # Tests for Nullables and Optionals
 
  - label: "Send Test Command with optional arg set."

src/app/util/ember-compatibility-functions.cpp

@@ -503,9 +503,25 @@ CHIP_ERROR WriteSingleClusterData(ClusterInfo & aClusterInfo, TLV::TLVReader & a
  attributePathParams.mClusterId = aClusterInfo.mClusterId;
  attributePathParams.mAttributeId = aClusterInfo.mAttributeId;
 
+ // TODO: Refactor WriteSingleClusterData and all dependent functions to take ConcreteAttributePath instead of ClusterInfo
+ // as the input argument.
+ AttributeAccessInterface * attrOverride = findAttributeAccessOverride(aClusterInfo.mEndpointId, aClusterInfo.mClusterId);
+ if (attrOverride != nullptr)
+ {
+ ConcreteAttributePath path(aClusterInfo.mEndpointId, aClusterInfo.mClusterId, aClusterInfo.mAttributeId);
+ AttributeValueDecoder valueDecoder(aReader);
+ ReturnErrorOnFailure(attrOverride->Write(path, valueDecoder));
+
+ if (valueDecoder.TriedDecode())
+ {
+ return apWriteHandler->AddStatus(attributePathParams, Protocols::InteractionModel::Status::Success);
+ }
+ }
+
  auto imCode = WriteSingleClusterDataInternal(aClusterInfo, aReader, apWriteHandler);
  return apWriteHandler->AddStatus(attributePathParams, imCode);
 }
+
 } // namespace app
 } // namespace chip