Merge branch 'controller/write_multiple_attributes' into 'main'

chshu · chshu · commit 54c43e9f6738 · 2024-12-16T17:54:57.000+08:00
components/esp_matter_controller: write multiple attributes support

See merge request app-frameworks/esp-matter!979
diff --git a/components/esp_matter/esp_matter_client.cpp b/components/esp_matter/esp_matter_client.cpp
@@ -531,6 +531,57 @@ esp_err_t send_request(client::peer_device_t *remote_device, AttributePathParams
     return send_request(remote_device, attr_path, type, callback, timeout_ms);
 }
 
+esp_err_t send_request(client::peer_device_t *remote_device,
+                       ScopedMemoryBufferWithSize<AttributePathParams> &attr_paths, multiple_write_encodable_type &json_encodable,
+                       WriteClient::Callback &callback, const chip::Optional<uint16_t> &timeout_ms)
+{
+    VerifyOrReturnError(
+        json_encodable.GetJsonArraySize() == attr_paths.AllocatedSize(), ESP_ERR_INVALID_ARG,
+        ESP_LOGE(TAG, "The attr_values array length should be the same as the attr_paths array length"));
+    VerifyOrReturnError(remote_device->GetSecureSession().HasValue() &&
+                            !remote_device->GetSecureSession().Value()->IsGroupSession(),
+                        ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Invalid Session Type"));
+    auto client_deleter_callback = chip::Platform::MakeUnique<client_deleter_write_callback>(callback);
+    VerifyOrReturnError(client_deleter_callback, ESP_ERR_NO_MEM,
+                        ESP_LOGE(TAG, "Failed to allocate memory for client deleter callback"));
+    auto write_client = chip::Platform::MakeUnique<WriteClient>(remote_device->GetExchangeManager(),
+                                                                client_deleter_callback.get(), timeout_ms, false);
+    VerifyOrReturnError(write_client, ESP_ERR_NO_MEM, ESP_LOGE(TAG, "Failed to allocate memory for WriteClient"));
+
+    for (size_t i = 0; i < attr_paths.AllocatedSize(); ++i) {
+        ConcreteDataAttributePath path(attr_paths[i].mEndpointId, attr_paths[i].mClusterId, attr_paths[i].mAttributeId);
+        chip::Platform::ScopedMemoryBuffer<uint8_t> encoded_buf;
+        encoded_buf.Alloc(k_encoded_buf_size);
+        VerifyOrReturnError((encoded_buf.Get()), ESP_ERR_NO_MEM,
+                            ESP_LOGE(TAG, "Failed to alloc memory for encoded_buf"));
+        TLVReader reader;
+        TLVWriter writer;
+        TLVReader attr_val_reader;
+        writer.Init(encoded_buf.Get(), k_encoded_buf_size);
+        VerifyOrReturnError(json_encodable.EncodeTo(writer, chip::TLV::AnonymousTag(), i) == CHIP_NO_ERROR, ESP_FAIL,
+                            ESP_LOGE(TAG, "Failed to encode attribute value"));
+        VerifyOrReturnError(writer.Finalize() == CHIP_NO_ERROR, ESP_FAIL,
+                            ESP_LOGE(TAG, "Failed to finalize TLV writer"));
+        reader.Init(encoded_buf.Get(), writer.GetLengthWritten());
+        VerifyOrReturnError(reader.Next() == CHIP_NO_ERROR, ESP_FAIL, ESP_LOGE(TAG, "Failed to read next"));
+        VerifyOrReturnError(reader.GetType() == chip::TLV::TLVType::kTLVType_Structure, ESP_ERR_INVALID_ARG,
+                            ESP_LOGE(TAG, "The TLV type must be structure"));
+        VerifyOrReturnError(reader.OpenContainer(attr_val_reader) == CHIP_NO_ERROR, ESP_FAIL,
+                            ESP_LOGE(TAG, "Failed to open container"));
+        VerifyOrReturnError(attr_val_reader.Next() == CHIP_NO_ERROR, ESP_FAIL, ESP_LOGE(TAG, "Failed to read next"));
+        VerifyOrReturnError(write_client->PutPreencodedAttribute(path, attr_val_reader) == CHIP_NO_ERROR, ESP_FAIL,
+                            ESP_LOGE(TAG, "Failed to put pre-encoded attribute value to WriteClient"));
+    }
+
+    VerifyOrReturnError(write_client->SendWriteRequest(remote_device->GetSecureSession().Value()) == CHIP_NO_ERROR,
+                        ESP_FAIL, ESP_LOGE(TAG, "Failed to Send Write Request"));
+
+    // Release the write_client and client deleter callback as it will be managed by the client deleter callback
+    write_client.release();
+    client_deleter_callback.release();
+    return ESP_OK;
+}
+
 } // namespace write
 } // namespace interaction
 } // namespace client
diff --git a/components/esp_matter/esp_matter_client.h b/components/esp_matter/esp_matter_client.h
@@ -36,6 +36,7 @@ using chip::app::ReadClient;
 using chip::app::StatusIB;
 using chip::app::WriteClient;
 using chip::Messaging::ExchangeManager;
+using chip::Platform::ScopedMemoryBufferWithSize;
 using chip::System::Clock::Timeout;
 using chip::TLV::TLVReader;
 using client::peer_device_t;
@@ -78,6 +79,39 @@ class custom_encodable_type : public EncodableToTLV
     char *m_json_str = NULL;
 };
 
+class multiple_write_encodable_type
+{
+public:
+    multiple_write_encodable_type(const char *json_str)
+    {
+        json = cJSON_Parse(json_str);
+    }
+
+    ~multiple_write_encodable_type() { cJSON_Delete(json); }
+
+    CHIP_ERROR EncodeTo(chip::TLV::TLVWriter &writer, chip::TLV::Tag tag, size_t index)
+    {
+        cJSON *json_at_index = NULL;
+        if (!json) {
+            return CHIP_ERROR_INVALID_ARGUMENT;
+        }
+        if (json->type != cJSON_Array) {
+            json_at_index = json;
+        } else {
+            json_at_index = cJSON_GetArrayItem(json, index);
+        }
+        if (json_to_tlv(json_at_index, writer, tag) != ESP_OK) {
+            return CHIP_ERROR_INTERNAL;
+        }
+        return CHIP_NO_ERROR;
+    }
+
+    size_t GetJsonArraySize() { return static_cast<size_t>(cJSON_GetArraySize(json)); }
+
+private:
+    cJSON *json = NULL;
+};
+
 /** Command invoke APIs
  *
  * They can be used for all the commands of all the clusters, including the custom clusters.
@@ -185,6 +219,10 @@ esp_err_t send_request(client::peer_device_t *remote_device, AttributePathParams
 esp_err_t send_request(client::peer_device_t *remote_device, AttributePathParams &attr_path,
                        const chip::app::DataModel::EncodableToTLV &encodable, WriteClient::Callback &callback,
                        const chip::Optional<uint16_t> &timeout_ms);
+
+esp_err_t send_request(client::peer_device_t *remote_device, ScopedMemoryBufferWithSize<AttributePathParams> &attr_paths,
+                       multiple_write_encodable_type &json_encodable, WriteClient::Callback &callback,
+                       const chip::Optional<uint16_t> &timeout_ms);
 } // namespace write
 
 namespace subscribe {
diff --git a/components/esp_matter/utils/json_to_tlv.cpp b/components/esp_matter/utils/json_to_tlv.cpp
@@ -439,11 +439,17 @@ static esp_err_t encode_tlv_element(const cJSON *val, TLV::TLVWriter &writer, co
 esp_err_t json_to_tlv(const char *json_str, chip::TLV::TLVWriter &writer, chip::TLV::Tag tag)
 {
     cJSON *json = cJSON_Parse(json_str);
+    esp_err_t err =  json_to_tlv(json, writer, tag);
+    cJSON_Delete(json);
+    return err;
+}
+
+esp_err_t json_to_tlv(cJSON *json, chip::TLV::TLVWriter &writer, chip::TLV::Tag tag)
+{
     if (!json) {
         return ESP_ERR_INVALID_ARG;
     }
     if (json->type != cJSON_Object) {
-        cJSON_Delete(json);
         return ESP_ERR_INVALID_ARG;
     }
     element_context element_ctx;
@@ -454,7 +460,6 @@ esp_err_t json_to_tlv(const char *json_str, chip::TLV::TLVWriter &writer, chip::
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "Failed to encode tlv element");
     }
-    cJSON_Delete(json);
     return err;
 }
 
diff --git a/components/esp_matter/utils/json_to_tlv.h b/components/esp_matter/utils/json_to_tlv.h
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include "cJSON.h"
 #include <esp_err.h>
 #include <lib/core/TLV.h>
 #include <string>
@@ -55,4 +56,15 @@ const char k_floating_point_negative_infinity[] = "-INF";
  */
 esp_err_t json_to_tlv(const char *json_str, chip::TLV::TLVWriter &writer, chip::TLV::Tag tag);
 
+/** Convert a JSON object to the given TLVWriter
+ *
+ * @param[in]   json     The JSON object
+ * @param[out]  writer   The TLV output from the JSON object
+ * @param[in]   tag      The TLV tag of the TLV structure
+ *
+ * @return ESP_OK on success
+ * @return error in case of failure
+ */
+esp_err_t json_to_tlv(cJSON *json, chip::TLV::TLVWriter &writer, chip::TLV::Tag tag);
+
 } // namespace esp_matter
diff --git a/components/esp_matter_controller/commands/esp_matter_controller_write_command.cpp b/components/esp_matter_controller/commands/esp_matter_controller_write_command.cpp
@@ -46,7 +46,7 @@ void write_command::on_device_connected_fcn(void *context, ExchangeManager &exch
 {
     write_command *cmd = (write_command *)context;
     chip::OperationalDeviceProxy device_proxy(&exchangeMgr, sessionHandle);
-    esp_err_t err = interaction::write::send_request(&device_proxy, cmd->m_attr_path, cmd->m_attr_val,
+    esp_err_t err = interaction::write::send_request(&device_proxy, cmd->m_attr_paths, cmd->m_attr_vals,
                                                      cmd->m_chunked_callback, cmd->m_timed_write_timeout_ms);
     if (err != ESP_OK) {
         chip::Platform::Delete(cmd);
@@ -105,5 +105,37 @@ esp_err_t send_write_attr_command(uint64_t node_id, uint16_t endpoint_id, uint32
     return cmd->send_command();
 }
 
+esp_err_t send_write_attr_command(uint64_t node_id, ScopedMemoryBufferWithSize<uint16_t> &endpoint_ids,
+                                  ScopedMemoryBufferWithSize<uint32_t> &cluster_ids,
+                                  ScopedMemoryBufferWithSize<uint32_t> &attribute_ids, const char *attr_val_json_str,
+                                  chip::Optional<uint16_t> timed_write_timeout_ms)
+{
+    if (endpoint_ids.AllocatedSize() != cluster_ids.AllocatedSize() ||
+        endpoint_ids.AllocatedSize() != attribute_ids.AllocatedSize()) {
+        ESP_LOGE(TAG,
+                 "The endpoint_id array length should be the same as the cluster_ids array length"
+                 "and the attribute_ids array length");
+        return ESP_ERR_INVALID_ARG;
+    }
+    ScopedMemoryBufferWithSize<AttributePathParams> attr_paths;
+    ScopedMemoryBufferWithSize<EventPathParams> event_paths;
+    attr_paths.Alloc(endpoint_ids.AllocatedSize());
+    if (!attr_paths.Get()) {
+        ESP_LOGE(TAG, "Failed to alloc memory for attribute paths");
+        return ESP_ERR_NO_MEM;
+    }
+    for (size_t i = 0; i < attr_paths.AllocatedSize(); ++i) {
+        attr_paths[i] = AttributePathParams(endpoint_ids[i], cluster_ids[i], attribute_ids[i]);
+    }
+
+    write_command *cmd =
+        chip::Platform::New<write_command>(node_id, std::move(attr_paths), attr_val_json_str, timed_write_timeout_ms);
+    if (!cmd) {
+        ESP_LOGE(TAG, "Failed to alloc memory for read_command");
+        return ESP_ERR_NO_MEM;
+    }
+    return cmd->send_command();
+}
+
 } // namespace controller
 } // namespace esp_matter
diff --git a/components/esp_matter_controller/commands/esp_matter_controller_write_command.h b/components/esp_matter_controller/commands/esp_matter_controller_write_command.h
@@ -31,24 +31,48 @@ using chip::app::ConcreteDataAttributePath;
 using chip::app::StatusIB;
 using chip::app::WriteClient;
 using chip::Messaging::ExchangeManager;
+using chip::Platform::ScopedMemoryBufferWithSize;
 using chip::TLV::TLVElementType;
 using esp_matter::client::peer_device_t;
 using esp_matter::client::interaction::custom_encodable_type;
+using esp_matter::client::interaction::multiple_write_encodable_type;
 
 /** Write command class to send a write interaction command to a server **/
 class write_command : public WriteClient::Callback {
 public:
+    /** Constructor for command with multiple paths**/
+    write_command(uint64_t node_id, ScopedMemoryBufferWithSize<AttributePathParams> &&attr_paths,
+                  const char *attribute_val_str,
+                  const chip::Optional<uint16_t> timed_write_timeout_ms = chip::NullOptional)
+        : m_node_id(node_id)
+        , m_attr_paths(std::move(attr_paths))
+        , m_chunked_callback(this)
+        , m_attr_vals(attribute_val_str)
+        , m_timed_write_timeout_ms(timed_write_timeout_ms)
+        , on_device_connected_cb(on_device_connected_fcn, this)
+        , on_device_connection_failure_cb(on_device_connection_failure_fcn, this)
+    {
+    }
+
     /** Constructor for command with an attribute path**/
     write_command(uint64_t node_id, uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id,
                   const char *attribute_val_str,
                   const chip::Optional<uint16_t> timed_write_timeout_ms = chip::NullOptional)
         : m_node_id(node_id)
-        , m_attr_path(endpoint_id, cluster_id, attribute_id)
         , m_chunked_callback(this)
-        , m_attr_val(attribute_val_str, custom_encodable_type::interaction_type::k_write_attr)
+        , m_attr_vals(attribute_val_str)
         , m_timed_write_timeout_ms(timed_write_timeout_ms)
         , on_device_connected_cb(on_device_connected_fcn, this)
-        , on_device_connection_failure_cb(on_device_connection_failure_fcn, this) {}
+        , on_device_connection_failure_cb(on_device_connection_failure_fcn, this)
+    {
+        m_attr_paths.Alloc(1);
+        if (m_attr_paths.Get()) {
+            m_attr_paths[0] = AttributePathParams(endpoint_id, cluster_id, attribute_id);
+        } else {
+            ChipLogError(DeviceLayer, "Alloc space for attribute path failed!");
+            assert(0);
+        }
+    }
 
     ~write_command() {}
 
@@ -76,9 +100,9 @@ class write_command : public WriteClient::Callback {
 
 private:
     uint64_t m_node_id;
-    AttributePathParams m_attr_path;
+    ScopedMemoryBufferWithSize<AttributePathParams> m_attr_paths;
     ChunkedWriteCallback m_chunked_callback;
-    custom_encodable_type m_attr_val;
+    multiple_write_encodable_type m_attr_vals;
     chip::Optional<uint16_t> m_timed_write_timeout_ms;
 
     static void on_device_connected_fcn(void *context, ExchangeManager &exchangeMgr,
@@ -106,5 +130,23 @@ esp_err_t send_write_attr_command(uint64_t node_id, uint16_t endpoint_id, uint32
                                   const char *attr_val_json_str,
                                   chip::Optional<uint16_t> timed_write_timeout_ms = chip::NullOptional);
 
+/** Send write attribute command to multiple attribute paths
+ *
+ * @param[in] node_id Remote NodeId
+ * @param[in] endpoint_ids EndpointIds
+ * @param[in] cluster_ids ClusterIds
+ * @param[in] attribute_ids AttributeIds
+ * @param[in] attr_val_json_str Attribute value string with JSON format
+ *            (https://docs.espressif.com/projects/esp-matter/en/latest/esp32/developing.html#write-attribute-commands)
+ * @param[in] timed_write_timeout_ms Timeout in millisecond for timed-write attributes
+ *
+ * @return ESP_OK on success.
+ * @return error in case of failure.
+ */
+esp_err_t send_write_attr_command(uint64_t node_id, ScopedMemoryBufferWithSize<uint16_t> &endpoint_ids,
+                                  ScopedMemoryBufferWithSize<uint32_t> &cluster_ids,
+                                  ScopedMemoryBufferWithSize<uint32_t> &attribute_ids, const char *attr_val_json_str,
+                                  chip::Optional<uint16_t> timed_write_timeout_ms = chip::NullOptional);
+
 } // namespace controller
 } // namespace esp_matter
diff --git a/components/esp_matter_controller/core/esp_matter_controller_console.cpp b/components/esp_matter_controller/core/esp_matter_controller_console.cpp
@@ -460,20 +460,24 @@ static esp_err_t controller_write_attr_handler(int argc, char **argv)
     }
 
     uint64_t node_id = string_to_uint64(argv[0]);
-    uint16_t endpoint_id = string_to_uint16(argv[1]);
-    uint32_t cluster_id = string_to_uint32(argv[2]);
-    uint32_t attribute_id = string_to_uint32(argv[3]);
+    ScopedMemoryBufferWithSize<uint16_t> endpoint_ids;
+    ScopedMemoryBufferWithSize<uint32_t> cluster_ids;
+    ScopedMemoryBufferWithSize<uint32_t> attribute_ids;
+    ESP_RETURN_ON_ERROR(string_to_uint16_array(argv[1], endpoint_ids), TAG, "Failed to parse endpoint IDs");
+    ESP_RETURN_ON_ERROR(string_to_uint32_array(argv[2], cluster_ids), TAG, "Failed to parse cluster IDs");
+    ESP_RETURN_ON_ERROR(string_to_uint32_array(argv[3], attribute_ids), TAG, "Failed to parse attribute IDs");
+
     char *attribute_val_str = argv[4];
 
     if (argc > 5) {
         uint16_t timed_write_timeout_ms = string_to_uint16(argv[5]);
         if (timed_write_timeout_ms > 0) {
-            return controller::send_write_attr_command(node_id, endpoint_id, cluster_id, attribute_id,
+            return controller::send_write_attr_command(node_id, endpoint_ids, cluster_ids, attribute_ids,
                                                        attribute_val_str, chip::MakeOptional(timed_write_timeout_ms));
         }
     }
 
-    return controller::send_write_attr_command(node_id, endpoint_id, cluster_id, attribute_id, attribute_val_str);
+    return controller::send_write_attr_command(node_id, endpoint_ids, cluster_ids, attribute_ids, attribute_val_str);
 }
 
 static esp_err_t controller_read_event_handler(int argc, char **argv)
@@ -639,14 +643,16 @@ esp_err_t controller_register_commands()
         {
             .name = "read-attr",
             .description = "Read attributes of the nodes.\n"
-                           "\tUsage: controller read-attr <node-id> <endpoint-id> <cluster-id> <attr-id>",
+                           "\tUsage: controller read-attr <node-id> <endpoint-ids> <cluster-ids> <attr-ids>\n"
+                           "\tNotes: endpoint-ids can represent a single or multiple endpoints, e.g. '0' or '0,1'. "
+                           "And the same applies to cluster-ids, attr-ids, and event-ids.",
             .handler = controller_read_attr_handler,
         },
         {
             .name = "write-attr",
             .description =
                 "Write attributes of the nodes.\n"
-                "\tUsage: controller write-attr <node-id> <endpoint-id> <cluster-id> <attr-id> <attr-value> [timed_write_timeout_ms]\n"
+                "\tUsage: controller write-attr <node-id> <endpoint-ids> <cluster-ids> <attr-ids> <attr-value> [timed_write_timeout_ms]\n"
                 "\tNotes: attr-value should be a JSON object that contains the attribute value JSON item."
                 "You can get the format of the attr-value from "
                 "https://docs.espressif.com/projects/esp-matter/en/latest/esp32/"
@@ -656,20 +662,20 @@ esp_err_t controller_register_commands()
         {
             .name = "read-event",
             .description = "Read events of the nodes.\n"
-                           "\tUsage: controller read-event <node-id> <endpoint-id> <cluster-id> <event-id>",
+                           "\tUsage: controller read-event <node-id> <endpoint-ids> <cluster-ids> <event-ids>",
             .handler = controller_read_event_handler,
         },
         {
             .name = "subs-attr",
             .description = "Subscribe attributes of the nodes.\n"
-                           "\tUsage: controller subs-attr <node-id> <endpoint-id> <cluster-id> <attr-id> "
+                           "\tUsage: controller subs-attr <node-id> <endpoint-ids> <cluster-ids> <attr-ids> "
                            "<min-interval> <max-interval>",
             .handler = controller_subscribe_attr_handler,
         },
         {
             .name = "subs-event",
             .description = "Subscribe events of the nodes.\n"
-                           "\tUsage: controller subs-attr <node-id> <endpoint-id> <cluster-id> <event-id> "
+                           "\tUsage: controller subs-event <node-id> <endpoint-ids> <cluster-ids> <event-ids> "
                            "<min-interval> <max-interval>",
             .handler = controller_subscribe_event_handler,
         },
diff --git a/docs/en/developing.rst b/docs/en/developing.rst

Original file line number	Diff line number	Diff line change
`@@ -439,11 +439,17 @@ static esp_err_t encode_tlv_element(const cJSON *val, TLV::TLVWriter &writer, co`
`439`	`439`	`esp_err_t json_to_tlv(const char *json_str, chip::TLV::TLVWriter &writer, chip::TLV::Tag tag)`
`440`	`440`	`{`
`441`	`441`	`cJSON *json = cJSON_Parse(json_str);`
	`442`	`+ esp_err_t err = json_to_tlv(json, writer, tag);`
	`443`	`+ cJSON_Delete(json);`
	`444`	`+ return err;`
	`445`	`+}`
	`446`	`+`
	`447`	`+esp_err_t json_to_tlv(cJSON *json, chip::TLV::TLVWriter &writer, chip::TLV::Tag tag)`
	`448`	`+{`
`442`	`449`	`if (!json) {`
`443`	`450`	`return ESP_ERR_INVALID_ARG;`
`444`	`451`	`}`
`445`	`452`	`if (json->type != cJSON_Object) {`
`446`		`- cJSON_Delete(json);`
`447`	`453`	`return ESP_ERR_INVALID_ARG;`
`448`	`454`	`}`
`449`	`455`	`element_context element_ctx;`
`@@ -454,7 +460,6 @@ esp_err_t json_to_tlv(const char *json_str, chip::TLV::TLVWriter &writer, chip::`
`454`	`460`	`if (err != ESP_OK) {`
`455`	`461`	`ESP_LOGE(TAG, "Failed to encode tlv element");`
`456`	`462`	`}`
`457`		`- cJSON_Delete(json);`
`458`	`463`	`return err;`
`459`	`464`	`}`
`460`	`465`