Merge branch 'compat-fixes-1-4-2' into 'release/v1.4.2'

chshu · chshu · commit 498a96bed031 · 2025-10-31T06:58:18.000Z
[v1.4.2] compatibility fixes for air quality and temperature unit attributes

See merge request app-frameworks/esp-matter!1276
diff --git a/components/esp_matter/data_model/attribute_exceptions.yaml b/components/esp_matter/data_model/attribute_exceptions.yaml
@@ -0,0 +1,21 @@
+# List of attributes where we did not add the ATTRIBUTE_FLAG_MANAGED_INTERNALLY.
+# These are mostly the cases where AAI is not registered for the cluster and
+# attribute is of primitive type.
+AttributesWithOverridenManagedInternallyFlag:
+  0x005B:
+    name: AirQuality
+    attributes:
+      0x0000: AirQuality
+  0x0201:
+    name: Thermostat
+    attributes:
+      0x0000: LocalTemperature
+      0x001A: RemoteSensing
+
+# List of attributes that have get_val/set_val extentions which reads the attributes
+# using the connectedhomeip APIs and populate the esp_matter_attr_val_t.
+AttributesWithSetterGetterAPIExceptions:
+  0x002D:
+    name: UnitLocalization
+    attributes:
+      0x0000: TemperatureUnit
diff --git a/components/esp_matter/data_model/esp_matter_attribute.cpp b/components/esp_matter/data_model/esp_matter_attribute.cpp
@@ -1946,7 +1946,7 @@ namespace attribute {
 
 attribute_t *create_local_temperature(cluster_t *cluster, nullable<int16_t> value)
 {
-    return esp_matter::attribute::create(cluster, Thermostat::Attributes::LocalTemperature::Id, ATTRIBUTE_FLAG_NULLABLE | ATTRIBUTE_FLAG_MANAGED_INTERNALLY,
+    return esp_matter::attribute::create(cluster, Thermostat::Attributes::LocalTemperature::Id, ATTRIBUTE_FLAG_NULLABLE,
                                          esp_matter_nullable_int16(value));
 }
 
@@ -2067,7 +2067,7 @@ attribute_t *create_min_setpoint_dead_band(cluster_t *cluster, int8_t value)
 attribute_t *create_remote_sensing(cluster_t *cluster, uint8_t value)
 {
     return esp_matter::attribute::create(cluster, Thermostat::Attributes::RemoteSensing::Id,
-                                         ATTRIBUTE_FLAG_NONVOLATILE | ATTRIBUTE_FLAG_WRITABLE | ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_bitmap8(value));
+                                         ATTRIBUTE_FLAG_NONVOLATILE | ATTRIBUTE_FLAG_WRITABLE, esp_matter_bitmap8(value));
 }
 
 attribute_t *create_control_sequence_of_operation(cluster_t *cluster, uint8_t value)
@@ -2347,7 +2347,13 @@ namespace attribute {
 
 attribute_t *create_air_quality(cluster_t *cluster, uint8_t value)
 {
-    return esp_matter::attribute::create(cluster, AirQuality::Attributes::AirQuality::Id, ATTRIBUTE_FLAG_MANAGED_INTERNALLY,
+    // Storage of this attribute was moved from esp-matter to connectedhomeip during the v1.4.2 release by
+    // implementing the AAI in connectedhomeip.
+    // For most clusters, AAI registration occurs in the cluster-init callback, but for this cluster,
+    // it is delegated to the application layer. So, in the esp-matter's workflow, no one registers the AAI.
+    // And, as this attribute is of primitive type, we can discard the ATTRIBUTE_FLAG_MANAGED_INTERNALLY flag
+    // and storage can be managed by esp-matter.
+    return esp_matter::attribute::create(cluster, AirQuality::Attributes::AirQuality::Id, ATTRIBUTE_FLAG_NONE,
                                          esp_matter_enum8(value));
 }
 
diff --git a/components/esp_matter/data_model/esp_matter_cluster.cpp b/components/esp_matter/data_model/esp_matter_cluster.cpp
@@ -784,6 +784,9 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
     VerifyOrReturnValue(cluster, NULL, ESP_LOGE(TAG, "Could not create cluster. cluster_id: 0x%08" PRIX32, UnitLocalization::Id));
 
     if (flags & CLUSTER_FLAG_SERVER) {
+
+        static const auto plugin_server_init_cb = CALL_ONCE(MatterUnitLocalizationPluginServerInitCallback);
+        set_plugin_server_init_callback(cluster, plugin_server_init_cb);
         add_function_list(cluster, function_list, function_flags);
 
         /* Attributes managed internally */
@@ -1403,7 +1406,7 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         /* Attributes managed internally */
         global::attribute::create_feature_map(cluster, 0);
 
-        attribute::create_air_quality(cluster, 0);
+        attribute::create_air_quality(cluster, config->air_quality);
 
         /* Attributes not managed internally */
         global::attribute::create_cluster_revision(cluster, cluster_revision);
diff --git a/components/esp_matter/data_model/esp_matter_cluster.h b/components/esp_matter/data_model/esp_matter_cluster.h
@@ -354,7 +354,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* thermostat_user_interface_configuration */
 
 namespace air_quality {
-using config_t = common::config_t;
+typedef struct config {
+    uint8_t air_quality;
+    config() : air_quality(0) {}
+} config_t;
 
 cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
 } /* air_quality */
diff --git a/components/esp_matter/data_model/esp_matter_data_model.cpp b/components/esp_matter/data_model/esp_matter_data_model.cpp
@@ -27,8 +27,6 @@
 #include <lib/core/DataModelTypes.h>
 #include <app/clusters/identify-server/identify-server.h>
 #include <app/util/endpoint-config-api.h>
-#include "app/server/Server.h"
-#include "credentials/GroupDataProviderImpl.h"
 
 #define ESP_MATTER_MAX_DEVICE_TYPE_COUNT CONFIG_ESP_MATTER_MAX_DEVICE_TYPE_COUNT
 
@@ -42,6 +40,13 @@ using chip::kInvalidCommandId;
 using chip::kInvalidClusterId;
 using chip::kInvalidEndpointId;
 
+// This is the hack to preserve and defer setting the temperature unit in the endpoint::enable()
+// we have an exception for this in attribute::create() to cache for later use in endpoint::enable()
+#ifdef CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+#include <app/clusters/unit-localization-server/unit-localization-server.h>
+uint8_t g_temperature_unit = 0;
+#endif // CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+
 namespace esp_matter {
 struct _attribute_base_t {
     uint16_t flags; // This struct is for attributes managed internally.
@@ -529,6 +534,24 @@ esp_err_t enable(endpoint_t *endpoint)
     }
     ESP_LOGI(TAG, "Dynamic endpoint %" PRIu16 " added", current_endpoint->endpoint_id);
 
+
+#ifdef CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+// set the temperature unit from unit localization cluster
+{
+    using namespace ::chip::app::Clusters;
+    attribute_t *temperature_unit_attr = attribute::get(current_endpoint->endpoint_id,
+                                                        UnitLocalization::Id,
+                                                        UnitLocalization::Attributes::TemperatureUnit::Id);
+    if (temperature_unit_attr) {
+        auto temp_unit = static_cast<UnitLocalization::TempUnitEnum>(g_temperature_unit);
+        CHIP_ERROR chip_err = UnitLocalization::UnitLocalizationServer::Instance().SetTemperatureUnit(temp_unit);
+        if (chip_err != CHIP_NO_ERROR) {
+            ESP_LOGW(TAG, "Failed to set temperature unit, err:%" CHIP_ERROR_FORMAT, chip_err.Format());
+        }
+    }
+}
+#endif // CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+
     return err;
 
 cleanup:
@@ -684,6 +707,15 @@ attribute_t *create(cluster_t *cluster, uint32_t attribute_id, uint16_t flags, e
 
     /* Add */
     SinglyLinkedList<_attribute_base_t>::append(&current_cluster->attribute_list, attribute);
+
+    // this is an exception to keep the sdk experience same as before v1.4.2 release
+#ifdef CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+    if (cluster::get_id(cluster) == chip::app::Clusters::UnitLocalization::Id &&
+        attribute_id == chip::app::Clusters::UnitLocalization::Attributes::TemperatureUnit::Id) {
+        g_temperature_unit = val.val.u8;
+    }
+#endif // CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+
     return (attribute_t *)attribute;
 }
 
@@ -774,11 +806,131 @@ static void deferred_attribute_write(chip::System::Layer *layer, void *attribute
                      current_attribute->val);
 }
 
+// This is pure hack to not-break the sdk experience with v1.4.2 release
+// Some attributes were moved from external storage to internal storage and the set_val/get_val APIs
+// silently broke the application layer. This is a hack to not-break the sdk experience with v1.4.2 release
+namespace {
+
+using namespace ::chip::app::Clusters;
+using namespace ::chip::app::Clusters::UnitLocalization;
+
+// Helper function to find the cluster_id and attribute_id for internally managed attributes
+esp_err_t find_cluster_and_endpoint_id_for_internally_managed_attribute(_attribute_base_t *attribute_base,
+                                                                 uint16_t *endpoint_id, uint32_t *cluster_id)
+{
+    _node_t *node = (_node_t *)node::get();
+    if (!node) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    for (_endpoint_t *endpoint = node->endpoint_list; endpoint != nullptr; endpoint = endpoint->next) {
+        for (_cluster_t *cluster = endpoint->cluster_list; cluster != nullptr; cluster = cluster->next) {
+            for (_attribute_base_t *attr = cluster->attribute_list; attr != nullptr; attr = attr->next) {
+                if (attr == attribute_base) {
+                    *endpoint_id = endpoint->endpoint_id;
+                    *cluster_id = cluster::get_id((cluster_t *)cluster);
+                    return ESP_OK;
+                }
+            }
+        }
+    }
+
+    return ESP_ERR_NOT_FOUND;
+}
+
+std::optional<esp_err_t> get_val_with_compatibility_exceptions(_attribute_t *attribute,
+                                                                esp_matter_attr_val_t *val)
+{
+    uint32_t cluster_id = kInvalidClusterId;
+    uint16_t endpoint_id = kInvalidEndpointId;
+
+    if (!(attribute->flags & ATTRIBUTE_FLAG_MANAGED_INTERNALLY)) {
+        // For non-internally-managed attributes, we can get cluster_id and endpoint_id directly
+        cluster_id = attribute->cluster_id;
+        endpoint_id = attribute->endpoint_id;
+    } else {
+        esp_err_t err = find_cluster_and_endpoint_id_for_internally_managed_attribute(attribute, &endpoint_id, &cluster_id);
+        VerifyOrReturnError(err == ESP_OK, err,
+            ESP_LOGE(TAG, "Failed to find cluster_id and endpoint_id for internally managed attribute"));
+    }
+
+    switch (cluster_id) {
+#ifdef CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+        case UnitLocalization::Id: {
+            switch (attribute->attribute_id) {
+                case Attributes::TemperatureUnit::Id: {
+                    lock::status_t lock_status = lock::chip_stack_lock(portMAX_DELAY);
+                    if (lock_status != lock::SUCCESS) {
+                        return ESP_ERR_INVALID_STATE;
+                    }
+                    auto temperature_unit = UnitLocalizationServer::Instance().GetTemperatureUnit();
+                    lock::chip_stack_unlock();
+                    esp_matter_attr_val_t read_val = esp_matter_enum8(static_cast<uint8_t>(temperature_unit));
+                    *val = read_val;
+                    return ESP_OK;
+                }
+            }
+        }
+#endif // CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+    }
+
+    return std::nullopt;
+}
+
+std::optional<esp_err_t> set_val_with_compatibility_exceptions(_attribute_t *attribute,
+                                                                esp_matter_attr_val_t *val)
+{
+    uint32_t cluster_id = kInvalidClusterId;
+    uint16_t endpoint_id = kInvalidEndpointId;
+
+    if (!(attribute->flags & ATTRIBUTE_FLAG_MANAGED_INTERNALLY)) {
+        // For non-internally-managed attributes, we can get cluster_id and endpoint_id directly
+        cluster_id = attribute->cluster_id;
+        endpoint_id = attribute->endpoint_id;
+    } else {
+        esp_err_t err = find_cluster_and_endpoint_id_for_internally_managed_attribute(attribute, &endpoint_id, &cluster_id);
+        VerifyOrReturnError(err == ESP_OK, err,
+            ESP_LOGE(TAG, "Failed to find cluster_id and endpoint_id for internally managed attribute"));
+    }
+
+    switch (cluster_id) {
+#ifdef CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+
+        case UnitLocalization::Id: {
+            switch (attribute->attribute_id) {
+                case Attributes::TemperatureUnit::Id: {
+                    auto temp_unit = static_cast<TempUnitEnum>(val->val.u8);
+                    lock::status_t lock_status = lock::chip_stack_lock(portMAX_DELAY);
+                    if (lock_status != lock::SUCCESS) {
+                        return ESP_ERR_INVALID_STATE;
+                    }
+                    CHIP_ERROR chip_err = UnitLocalizationServer::Instance().SetTemperatureUnit(temp_unit);
+                    lock::chip_stack_unlock();
+                    if (chip_err != CHIP_NO_ERROR) {
+                        ESP_LOGE(TAG, "Failed to set temperature unit, err:%" CHIP_ERROR_FORMAT, chip_err.Format());
+                        return ESP_FAIL;
+                    }
+                    return ESP_OK;
+                }
+            }
+        }
+#endif // CONFIG_SUPPORT_UNIT_LOCALIZATION_CLUSTER
+    }
+
+    return std::nullopt;
+}
+} // anonymous namespace
+
 esp_err_t set_val(attribute_t *attribute, esp_matter_attr_val_t *val)
 {
     VerifyOrReturnError(attribute, ESP_FAIL, ESP_LOGE(TAG, "Attribute cannot be NULL"));
     _attribute_t *current_attribute = (_attribute_t *)attribute;
 
+    auto err = set_val_with_compatibility_exceptions(current_attribute, val);
+    if (err.has_value()) {
+        return err.value();
+    }
+
     ESP_RETURN_ON_FALSE(!(current_attribute->flags & ATTRIBUTE_FLAG_MANAGED_INTERNALLY), ESP_ERR_NOT_SUPPORTED, TAG,
                         "Attribute is not managed by esp matter data model");
 
@@ -825,6 +977,11 @@ esp_err_t get_val(attribute_t *attribute, esp_matter_attr_val_t *val)
     VerifyOrReturnError(attribute, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Attribute cannot be NULL"));
     _attribute_t *current_attribute = (_attribute_t *)attribute;
 
+    auto err = get_val_with_compatibility_exceptions(current_attribute, val);
+    if (err.has_value()) {
+        return err.value();
+    }
+
     ESP_RETURN_ON_FALSE(!(current_attribute->flags & ATTRIBUTE_FLAG_MANAGED_INTERNALLY), ESP_ERR_NOT_SUPPORTED, TAG,
                         "Attribute is not managed by esp matter data model");
     memcpy((void *)val, (void *)&current_attribute->val, sizeof(esp_matter_attr_val_t));

Original file line number	Diff line number	Diff line change
`@@ -1946,7 +1946,7 @@ namespace attribute {`
`1946`	`1946`
`1947`	`1947`	`attribute_t create_local_temperature(cluster_t cluster, nullable<int16_t> value)`
`1948`	`1948`	`{`
`1949`		`- return esp_matter::attribute::create(cluster, Thermostat::Attributes::LocalTemperature::Id, ATTRIBUTE_FLAG_NULLABLE \| ATTRIBUTE_FLAG_MANAGED_INTERNALLY,`
	`1949`	`+ return esp_matter::attribute::create(cluster, Thermostat::Attributes::LocalTemperature::Id, ATTRIBUTE_FLAG_NULLABLE,`
`1950`	`1950`	`esp_matter_nullable_int16(value));`
`1951`	`1951`	`}`
`1952`	`1952`
`@@ -2067,7 +2067,7 @@ attribute_t create_min_setpoint_dead_band(cluster_t cluster, int8_t value)`
`2067`	`2067`	`attribute_t create_remote_sensing(cluster_t cluster, uint8_t value)`
`2068`	`2068`	`{`
`2069`	`2069`	`return esp_matter::attribute::create(cluster, Thermostat::Attributes::RemoteSensing::Id,`
`2070`		`- ATTRIBUTE_FLAG_NONVOLATILE \| ATTRIBUTE_FLAG_WRITABLE \| ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_bitmap8(value));`
	`2070`	`+ ATTRIBUTE_FLAG_NONVOLATILE \| ATTRIBUTE_FLAG_WRITABLE, esp_matter_bitmap8(value));`
`2071`	`2071`	`}`
`2072`	`2072`
`2073`	`2073`	`attribute_t create_control_sequence_of_operation(cluster_t cluster, uint8_t value)`
`@@ -2347,7 +2347,13 @@ namespace attribute {`
`2347`	`2347`
`2348`	`2348`	`attribute_t create_air_quality(cluster_t cluster, uint8_t value)`
`2349`	`2349`	`{`
`2350`		`- return esp_matter::attribute::create(cluster, AirQuality::Attributes::AirQuality::Id, ATTRIBUTE_FLAG_MANAGED_INTERNALLY,`
	`2350`	`+ // Storage of this attribute was moved from esp-matter to connectedhomeip during the v1.4.2 release by`
	`2351`	`+ // implementing the AAI in connectedhomeip.`
	`2352`	`+ // For most clusters, AAI registration occurs in the cluster-init callback, but for this cluster,`
	`2353`	`+ // it is delegated to the application layer. So, in the esp-matter's workflow, no one registers the AAI.`
	`2354`	`+ // And, as this attribute is of primitive type, we can discard the ATTRIBUTE_FLAG_MANAGED_INTERNALLY flag`
	`2355`	`+ // and storage can be managed by esp-matter.`
	`2356`	`+ return esp_matter::attribute::create(cluster, AirQuality::Attributes::AirQuality::Id, ATTRIBUTE_FLAG_NONE,`
`2351`	`2357`	`esp_matter_enum8(value));`
`2352`	`2358`	`}`
`2353`	`2359`