According to the review comments:

1. Removed the hardcoaded size of the array to store endpointUniqueId
2. Changed the way endpointUniqueId is set. Using the add end point engine rather than a new setter.
3. Not using std::string instead changed to char array.

Author: suneelsignify

scripts/tools/check_includes_config.py

@@ -193,6 +193,4 @@
 
     # nrfconnect test runner
     'src/test_driver/nrfconnect/main/runner.cpp': {'vector'},
-
-    'src/app/util/af-types.h': {'string'},
 }

src/app/clusters/descriptor/descriptor.cpp

@@ -212,16 +212,13 @@ CHIP_ERROR DescriptorAttrAccess::ReadDeviceAttribute(EndpointId endpoint, Attrib
     return err;
 }
 
-CHIP_ERROR EncodeString(AttributeValueEncoder & encoder, const char * buf, size_t maxBufSize)
-{
-    return encoder.Encode(chip::CharSpan(buf, strnlen(buf, maxBufSize)));
-}
-
 CHIP_ERROR DescriptorAttrAccess::ReadEndpointUniqueId(EndpointId endpoint, AttributeValueEncoder & aEncoder)
 {
-    char endpointUniqueId[32 + 1] = { 0 };
-    GetEndpointUniqueIdForEndPoint(endpoint, endpointUniqueId);
-    return EncodeString(aEncoder, endpointUniqueId, 32);
+    char epUniqueId[Attributes::EndpointUniqueId::TypeInfo::MaxLength() + 1] = { 0 };
+    chip::MutableCharSpan epUniqueIdSpan(epUniqueId);
+    GetEndpointUniqueIdForEndPoint(endpoint, epUniqueIdSpan);
+    
+    return aEncoder.Encode(epUniqueIdSpan);
 }
 
 CHIP_ERROR DescriptorAttrAccess::ReadServerClusters(EndpointId endpoint, AttributeValueEncoder & aEncoder)

src/app/util/af-types.h

@@ -25,7 +25,6 @@
 
 #include <stdbool.h> // For bool
 #include <stdint.h>  // For various uint*_t types
-#include <string>    // For string
 
 #include <app/util/AttributesChangedListener.h>
 #include <app/util/MarkAttributeDirty.h>
@@ -238,7 +237,10 @@ struct EmberAfDefinedEndpoint
      */
     chip::Span<const chip::app::Clusters::Descriptor::Structs::SemanticTagStruct::Type> tagList;
 
-    std::string endpointUniqueId;
+    /**
+     * Unique Id for this end point. 
+     */
+    char endpointUniqueId[chip::app::Clusters::Descriptor::Attributes::EndpointUniqueId::TypeInfo::MaxLength()] = {0};
 };
 
 /**

src/app/util/attribute-storage.cpp

@@ -265,7 +265,7 @@ uint16_t emberAfGetDynamicIndexFromEndpoint(EndpointId id)
 
 CHIP_ERROR emberAfSetDynamicEndpoint(uint16_t index, EndpointId id, const EmberAfEndpointType * ep,
                                      const Span<DataVersion> & dataVersionStorage, Span<const EmberAfDeviceType> deviceTypeList,
-                                     EndpointId parentEndpointId)
+                                     chip::CharSpan endpointUniqueId, EndpointId parentEndpointId)
 {
     auto realIndex = index + FIXED_ENDPOINT_COUNT;
 
@@ -317,10 +317,14 @@ CHIP_ERROR emberAfSetDynamicEndpoint(uint16_t index, EndpointId id, const EmberA
             }
         }
     }
-    emAfEndpoints[index].endpoint       = id;
-    emAfEndpoints[index].deviceTypeList = deviceTypeList;
-    emAfEndpoints[index].endpointType   = ep;
-    emAfEndpoints[index].dataVersions   = dataVersionStorage.data();
+    emAfEndpoints[index].endpoint         = id;
+    emAfEndpoints[index].deviceTypeList   = deviceTypeList;
+    emAfEndpoints[index].endpointType     = ep;
+    emAfEndpoints[index].dataVersions     = dataVersionStorage.data();
+    memcpy((void *)(emAfEndpoints[index].endpointUniqueId), endpointUniqueId.data(), 
+           endpointUniqueId.size() > Clusters::Descriptor::Attributes::EndpointUniqueId::TypeInfo::MaxLength()? 
+           Clusters::Descriptor::Attributes::EndpointUniqueId::TypeInfo::MaxLength() : endpointUniqueId.size());
+
     // Start the endpoint off as disabled.
     emAfEndpoints[index].bitmask.Clear(EmberAfEndpointOptions::isEnabled);
     emAfEndpoints[index].parentEndpointId = parentEndpointId;
@@ -1080,15 +1084,19 @@ CHIP_ERROR GetSemanticTagForEndpointAtIndex(EndpointId endpoint, size_t index,
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR GetEndpointUniqueIdForEndPoint(EndpointId endpoint, char * buf)
+CHIP_ERROR GetEndpointUniqueIdForEndPoint(EndpointId endpoint, chip::MutableCharSpan & epUniqueIdMutSpan)
 {
     uint16_t endpointIndex = emberAfIndexFromEndpoint(endpoint);
 
     if (endpointIndex == 0xFFFF)
     {
         return CHIP_ERROR_NOT_FOUND;
     }
-    strcpy(buf, emAfEndpoints[endpointIndex].endpointUniqueId.c_str());
+    chip::CharSpan epUniqueIdSpan(emAfEndpoints[endpointIndex].endpointUniqueId, 
+                                  strnlen(emAfEndpoints[endpointIndex].endpointUniqueId,
+                                  Clusters::Descriptor::Attributes::EndpointUniqueId::TypeInfo::MaxLength()));
+    chip::CopyCharSpanToMutableCharSpan(epUniqueIdSpan, epUniqueIdMutSpan);
+
     return CHIP_NO_ERROR;
 }
 
@@ -1116,18 +1124,6 @@ CHIP_ERROR SetTagList(EndpointId endpoint, Span<const Clusters::Descriptor::Stru
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR SetEndPointUniqueId(chip::EndpointId endpoint, std::string endpointUniqueId)
-{
-    uint16_t endpointIndex = emberAfIndexFromEndpoint(endpoint);
-    if (endpointIndex == 0xFFFF)
-    {
-        return CHIP_ERROR_INVALID_ARGUMENT;
-    }
-
-    emAfEndpoints[endpointIndex].endpointUniqueId = endpointUniqueId;
-    return CHIP_NO_ERROR;
-}
-
 // Returns the cluster of Nth server or client cluster,
 // depending on server toggle.
 const EmberAfCluster * emberAfGetNthCluster(EndpointId endpoint, uint8_t n, bool server)

src/app/util/attribute-storage.h

@@ -208,9 +208,7 @@ CHIP_ERROR GetSemanticTagForEndpointAtIndex(chip::EndpointId endpoint, size_t in
 CHIP_ERROR SetTagList(chip::EndpointId endpoint,
                       chip::Span<const chip::app::Clusters::Descriptor::Structs::SemanticTagStruct::Type> tagList);
 
-CHIP_ERROR GetEndpointUniqueIdForEndPoint(chip::EndpointId endpoint, char * buf);
-
-CHIP_ERROR SetEndPointUniqueId(chip::EndpointId endpoint, std::string endpointUniqueId);
+CHIP_ERROR GetEndpointUniqueIdForEndPoint(chip::EndpointId endpoint, chip::MutableCharSpan & epUniqueIdMutSpan);
 
 // Returns number of clusters put into the passed cluster list
 // for the given endpoint and client/server polarity
@@ -252,6 +250,8 @@ void emberAfEndpointConfigure();
 // An optional device type list can be passed in as well. If provided, the memory
 // backing the list needs to remain allocated until this dynamic endpoint is cleared.
 //
+// An optional endpointUniqueId can be passed. 
+//
 // An optional parent endpoint id should be passed for child endpoints of composed device.
 //
 // Returns  CHIP_NO_ERROR                   No error.
@@ -262,7 +262,8 @@ void emberAfEndpointConfigure();
 CHIP_ERROR emberAfSetDynamicEndpoint(uint16_t index, chip::EndpointId id, const EmberAfEndpointType * ep,
                                      const chip::Span<chip::DataVersion> & dataVersionStorage,
                                      chip::Span<const EmberAfDeviceType> deviceTypeList = {},
-                                     chip::EndpointId parentEndpointId                  = chip::kInvalidEndpointId);
+                                     chip::CharSpan endpointUniqueId ={}, 
+                                     chip::EndpointId parentEndpointId = chip::kInvalidEndpointId);
 chip::EndpointId emberAfClearDynamicEndpoint(uint16_t index);
 uint16_t emberAfGetDynamicIndexFromEndpoint(chip::EndpointId id);
 /**