Merge branch 'attribute_update_cb' into 'main'

components/esp_matter: Add attribute update callback in case of attribute managed by SCI and AAI.

See merge request app-frameworks/esp-matter!1371

Author: dhrishi

components/esp_matter/data_model/esp_matter_data_model.cpp

@@ -293,8 +293,8 @@ esp_err_t set_callback(callback_t callback)
     return ESP_OK;
 }
 
-static esp_err_t execute_callback(callback_type_t type, uint16_t endpoint_id, uint32_t cluster_id,
-                                  uint32_t attribute_id, esp_matter_attr_val_t *val)
+esp_err_t execute_callback(callback_type_t type, uint16_t endpoint_id, uint32_t cluster_id,
+                           uint32_t attribute_id, esp_matter_attr_val_t *val)
 {
     if (attribute_callback) {
 #ifdef CONFIG_ESP_MATTER_ENABLE_DATA_MODEL

components/esp_matter/data_model/private/esp_matter_data_model_priv.h

@@ -61,6 +61,23 @@ namespace attribute {
  */
 esp_err_t get_val_internal(attribute_t *attribute, esp_matter_attr_val_t *val);
 
+/** Execute the attribute update callback
+ *
+ * This function executes the attribute update callback set via set_callback().
+ * This is used internally to notify the application about attribute changes.
+ *
+ * @param[in] type Callback type (PRE_UPDATE or POST_UPDATE).
+ * @param[in] endpoint_id Endpoint ID of the attribute.
+ * @param[in] cluster_id Cluster ID of the attribute.
+ * @param[in] attribute_id Attribute ID of the attribute.
+ * @param[in] val Pointer to the attribute value.
+ *
+ * @return ESP_OK on success.
+ * @return error in case of failure.
+ */
+esp_err_t execute_callback(callback_type_t type, uint16_t endpoint_id, uint32_t cluster_id,
+                           uint32_t attribute_id, esp_matter_attr_val_t *val);
+
 /** Set the attribute value in the esp-matter storage
  *
  * @param[in] attribute Attribute handle.

components/esp_matter/data_model_provider/esp_matter_data_model_provider.cpp

@@ -40,6 +40,27 @@ using namespace chip::app;
 
 constexpr char TAG[] = "DataModelProvider";
 
+namespace chip {
+namespace app {
+
+/**
+ * Accessor class for AttributeValueDecoder to get the TLV reader.
+ * This leverages the existing friend declaration in the SDK's AttributeValueDecoder.
+ */
+class TestOnlyAttributeValueDecoderAccessor
+{
+public:
+    TestOnlyAttributeValueDecoderAccessor(AttributeValueDecoder & decoder) : mDecoder(decoder) {}
+
+    const TLV::TLVReader & GetReader() { return mDecoder.mReader; }
+
+private:
+    AttributeValueDecoder & mDecoder;
+};
+
+} // namespace app
+} // namespace chip
+
 namespace {
 /// Attempts to read via an attribute access interface (AAI)
 ///
@@ -299,14 +320,51 @@ ActionReturnStatus provider::ReadAttribute(const ReadAttributeRequest &request,
 
 ActionReturnStatus provider::WriteAttribute(const WriteAttributeRequest &request, AttributeValueDecoder &decoder)
 {
+    attribute_t *attribute = attribute::get(request.path.mEndpointId, request.path.mClusterId,
+                                            request.path.mAttributeId);
+
+    // Decode the new value once - copy TLV reader to leave original decoder intact for mRegistry/AAI
+    esp_matter_attr_val_t new_val = esp_matter_invalid(nullptr);
+    
+    VerifyOrReturnValue(attribute, Protocols::InteractionModel::Status::UnsupportedAttribute);
+    
+    esp_matter_val_type_t current_val_type = attribute::get_val_type(attribute);
+    
+    TestOnlyAttributeValueDecoderAccessor accessor(decoder);
+    TLV::TLVReader reader_copy;
+    reader_copy.Init(accessor.GetReader());
+    AttributeValueDecoder decoder_copy(reader_copy, decoder.GetSubjectDescriptor());
+    attribute_data_decode_buffer data_buffer(current_val_type);
+    if (decoder_copy.Decode(data_buffer) == CHIP_NO_ERROR) {
+        new_val = data_buffer.get_attr_val();
+        // PRE_UPDATE callback
+        if (attribute::execute_callback(attribute::PRE_UPDATE, request.path.mEndpointId,
+                                        request.path.mClusterId, request.path.mAttributeId,
+                                        &new_val) != ESP_OK) {
+            return Protocols::InteractionModel::Status::Failure;
+        }
+    }
+
+    // Helper to execute POST_UPDATE callback
+    auto execute_post_update = [&]() {
+        
+        attribute::execute_callback(attribute::POST_UPDATE, request.path.mEndpointId,
+                                        request.path.mClusterId, request.path.mAttributeId, &new_val);
+    };
+
+    // mRegistry handles its own storage
     if (auto *cluster = mRegistry.Get(request.path); cluster != nullptr) {
-        return cluster->WriteAttribute(request, decoder);
+        ActionReturnStatus ret = cluster->WriteAttribute(request, decoder);
+        if (ret.IsSuccess()) {
+            execute_post_update();
+        }
+        return ret;
     }
+
     Status status = CheckDataModelPath(request.path);
     VerifyOrReturnValue(status == Protocols::InteractionModel::Status::Success,
                         CHIP_ERROR_IM_GLOBAL_STATUS_VALUE(status));
     cluster_t *cluster = cluster::get(request.path.mEndpointId, request.path.mClusterId);
-    attribute_t *attribute = attribute::get(cluster, request.path.mAttributeId);
     if (request.path.mDataVersion.HasValue()) {
         chip::DataVersion data_version;
         VerifyOrReturnValue(cluster::get_data_version(cluster, data_version) == ESP_OK,
@@ -315,6 +373,7 @@ ActionReturnStatus provider::WriteAttribute(const WriteAttributeRequest &request
                             Protocols::InteractionModel::Status::DataVersionMismatch);
     }
 
+    // AAI handles its own storage
     AttributeAccessInterface *aai =
         AttributeAccessInterfaceRegistry::Instance().Get(request.path.mEndpointId, request.path.mClusterId);
     std::optional<CHIP_ERROR> aai_result = TryWriteViaAccessInterface(request.path, aai, decoder);
@@ -323,21 +382,23 @@ ActionReturnStatus provider::WriteAttribute(const WriteAttributeRequest &request
             cluster::increase_data_version(cluster);
             AttributePathParams path(request.path.mEndpointId, request.path.mClusterId, request.path.mAttributeId);
             mContext->dataModelChangeListener.MarkDirty(path);
+            execute_post_update();
         }
         return *aai_result;
     }
 
-    esp_matter_attr_val_t val = esp_matter_invalid(nullptr);
-    VerifyOrReturnValue(attribute::get_val_internal(attribute, &val) == ESP_OK, Protocols::InteractionModel::Status::Failure);
-    attribute_data_decode_buffer data_buffer(val.type);
-    ReturnErrorOnFailure(decoder.Decode(data_buffer));
-    esp_err_t err =
-        attribute::update(request.path.mEndpointId, request.path.mClusterId, request.path.mAttributeId, &data_buffer.get_attr_val());
+    // Use set_val_internal with call_callbacks=false since we already called PRE_UPDATE
+    esp_err_t err = attribute::set_val_internal(attribute, &new_val, false);
     if (err == ESP_ERR_NO_MEM) {
         return Protocols::InteractionModel::Status::ResourceExhausted;
-    } else if (err != ESP_OK) {
+    } else if (err != ESP_OK && err != ESP_ERR_NOT_FINISHED) {
         return Protocols::InteractionModel::Status::Failure;
     }
+    // Increase data version and mark dirty
+    cluster::increase_data_version(cluster);
+    AttributePathParams path(request.path.mEndpointId, request.path.mClusterId, request.path.mAttributeId);
+    mContext->dataModelChangeListener.MarkDirty(path);
+    execute_post_update();
     return Protocols::InteractionModel::Status::Success;
 }