Created a new cluster object for the basic infromation culster to allow for a mutabel device location.

Author: hicklin

src/app/chip_data_model.gni

@@ -182,6 +182,7 @@ template("chip_data_model") {
 
     sources += [
       "${_app_root}/clusters/barrier-control-server/barrier-control-server.h",
+      "${_app_root}/clusters/basic-information/basic-information-cluster-objects.h",
       "${_app_root}/clusters/basic-information/basic-information.h",
       "${_app_root}/clusters/color-control-server/color-control-server.h",
       "${_app_root}/clusters/door-lock-server/door-lock-server.h",

src/app/clusters/basic-information/basic-information-cluster-objects.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/cluster-enums.h>
+
+
+namespace chip {
+namespace app {
+namespace Clusters {
+namespace BasicInformation {
+
+const uint32_t kMaxDeviceLocationNameLength = 128;
+using DeviceLocatioType = Attributes::DeviceLocation::TypeInfo::Type;
+
+
+struct MutableDeviceLocation : public DeviceLocatioType
+{
+    MutableDeviceLocation() {
+        MutableDeviceLocation(CharSpan(mLocationNameBuffer, 0), DataModel::NullNullable, DataModel::NullNullable);
+    }
+
+    MutableDeviceLocation(CharSpan aLocationName, DataModel::Nullable<int16_t> floorNumber, DataModel::Nullable<AreaTypeTag> aAreaTypeTag) {
+        Set(aLocationName, floorNumber, aAreaTypeTag);
+    }
+
+    MutableDeviceLocation & operator = (const MutableDeviceLocation & other) {
+        Set(other->locationName, other->floorNumber, other->areaType);
+        return *this;
+    }
+
+    MutableDeviceLocation(const MutableDeviceLocation & other)  : Nullable(other) {
+        *this = other;
+    }
+
+    // todo is this needed?
+    MutableDeviceLocation & operator = (const DeviceLocatioType & other) {
+        if (other.IsNull())
+        {
+            this->SetNull();
+            return *this;
+        }
+
+        Set(other->locationName, other->floorNumber, other->areaType);
+        return *this;
+    }
+
+    /**
+     * @brief Set the location name, floor number, and area type tag. The location name is truncated to kMaxDeviceLocationNameLength. The location name is deep copied.
+    */
+    void Set(CharSpan aLocationName, DataModel::Nullable<int16_t> aFloorNumber, DataModel::Nullable<AreaTypeTag> aAreaTypeTag) {
+
+        auto nameLength = aLocationName.size();
+
+        if (nameLength > kMaxDeviceLocationNameLength)
+        {
+            nameLength = kMaxDeviceLocationNameLength;
+        }
+
+        memcpy(mLocationNameBuffer, aLocationName.data(), nameLength);
+
+        this->SetNonNull();
+        this->Value().locationName = CharSpan(mLocationNameBuffer, nameLength);
+        this->Value().floorNumber = aFloorNumber;
+        this->Value().areaType = aAreaTypeTag;
+    }
+
+    // todo add setters and getters for all the attributes
+
+private:
+    char mLocationNameBuffer[kMaxDeviceLocationNameLength] = { 0 };
+};
+
+
+} // namespace BasicInformation
+} // namespace Clusters
+} // namespace app
+} // namespace chip

src/app/clusters/basic-information/basic-information.cpp

@@ -16,6 +16,7 @@
  *
  */
 
+#include "basic-information-cluster-objects.h"
 #include "basic-information.h"
 
 #include <app-common/zap-generated/attributes/Accessors.h>
@@ -423,12 +424,7 @@ CHIP_ERROR BasicAttrAccess::ReadMaxPathsPerInvoke(AttributeValueEncoder & aEncod
 
 CHIP_ERROR BasicAttrAccess::ReadDeviceLocation(AttributeValueEncoder & aEncoder)
 {
-
-    char locationNameBuffer[DeviceLayer::ConfigurationManager::kMaxDeviceLocationNameLength] = { 0 };
-
-    DeviceLocatioType deviceLocation({
-        .locationName = MutableCharSpan(locationNameBuffer),
-    });
+    MutableDeviceLocation deviceLocation;
 
     ReturnErrorOnFailure(ConfigurationMgr().GetDeviceLocation(deviceLocation));
 
@@ -437,11 +433,7 @@ CHIP_ERROR BasicAttrAccess::ReadDeviceLocation(AttributeValueEncoder & aEncoder)
 
 CHIP_ERROR BasicAttrAccess::WriteDeviceLocation(AttributeValueDecoder & aDecoder)
 {
-    char locationNameBuffer[DeviceLayer::ConfigurationManager::kMaxDeviceLocationNameLength] = { 0 };
-
-    DeviceLocatioType deviceLocation({
-        .locationName = MutableCharSpan(locationNameBuffer),
-    });
+    DeviceLocatioType deviceLocation;
 
     ReturnErrorOnFailure(aDecoder.Decode(deviceLocation));
 

src/include/platform/ConfigurationManager.h

@@ -33,13 +33,15 @@
 #endif
 
 #include <app-common/zap-generated/cluster-objects.h>
+#include <app/clusters/basic-information/basic-information-cluster-objects.h>
 #include <app/data-model/Nullable.h>
 #include <lib/core/ClusterEnums.h>
 #include <lib/support/Span.h>
 #include <platform/PersistedStorage.h>
 #include <platform/internal/CHIPDeviceLayerInternal.h>
 
 using DeviceLocatioType = chip::app::Clusters::BasicInformation::Attributes::DeviceLocation::TypeInfo::Type;
+using MutableDeviceLocation = chip::app::Clusters::BasicInformation::MutableDeviceLocation;
 
 namespace chip {
 namespace Ble {
@@ -80,7 +82,6 @@ class ConfigurationManager
         kMaxProductLabelLength          = 64,
         kMaxSerialNumberLength          = 32,
         kMaxUniqueIDLength              = 32,
-        kMaxDeviceLocationNameLength    = 128,
 #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
         kMinRotatingDeviceIDUniqueIDLength = 16,
         kRotatingDeviceIDUniqueIDLength    = CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID_LENGTH,
@@ -136,7 +137,7 @@ class ConfigurationManager
     virtual CHIP_ERROR GenerateUniqueId(char * buf, size_t bufSize)                    = 0;
     virtual CHIP_ERROR GetFailSafeArmed(bool & val)                                    = 0;
     virtual CHIP_ERROR SetFailSafeArmed(bool val)                                      = 0;
-    virtual CHIP_ERROR GetDeviceLocation(DeviceLocatioType & location)                 = 0;
+    virtual CHIP_ERROR GetDeviceLocation(MutableDeviceLocation & location)             = 0;
     virtual CHIP_ERROR SetDeviceLocation(DeviceLocatioType location)                   = 0;
 
     virtual CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo) = 0;

src/include/platform/internal/GenericConfigurationManagerImpl.h

@@ -86,7 +86,7 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
      *
      * Expects that location is initialised with a locationName CharSpan pointing to a buffer of size kMaxDeviceLocationNameLength.
      */
-    CHIP_ERROR GetDeviceLocation(DeviceLocatioType & location) override;
+    CHIP_ERROR GetDeviceLocation(MutableDeviceLocation & location) override;
     CHIP_ERROR SetDeviceLocation(DeviceLocatioType location) override;
     CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo) override;
     bool IsCommissionableDeviceTypeEnabled() override;

src/include/platform/internal/GenericConfigurationManagerImpl.ipp

@@ -587,43 +587,45 @@ CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::SetFailSafeArmed(bool v
 }
 
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetDeviceLocation(DeviceLocatioType & location)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetDeviceLocation(MutableDeviceLocation & location)
 {
-    uint8_t locationData[kMaxDeviceLocationNameLength + sizeof(DeviceLocatioType)];
+    uint8_t locationData[app::Clusters::BasicInformation::kMaxDeviceLocationNameLength + sizeof(DeviceLocatioType)];
     MutableByteSpan locationSpan(locationData);
 
     size_t outLen = 0;
-    ReturnErrorOnFailure(
-        ReadConfigValueBin(ConfigClass::kConfigKey_DeviceLocation, locationSpan.data(), locationSpan.size(), outLen));
+    auto err = ReadConfigValueBin(ConfigClass::kConfigKey_DeviceLocation, locationSpan.data(), locationSpan.size(), outLen);
+    if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+    {
+        location.SetNull();
+        return CHIP_NO_ERROR;
+    }
+    ReturnErrorOnFailure(err);
 
     TLV::TLVReader tlvReader;
     tlvReader.Init(locationSpan);
 
-    char locationNameBuffer[DeviceLayer::ConfigurationManager::kMaxDeviceLocationNameLength] = { 0 };
+    char locationNameBuffer[1] = { 0 };
     DeviceLocatioType loc({
-        .locationName = MutableCharSpan(locationNameBuffer),
+        .locationName = CharSpan(locationNameBuffer, 0),
     });
 
     ReturnErrorOnFailure(tlvReader.Next(TLV::AnonymousTag()));
     ReturnErrorOnFailure(loc->Decode(tlvReader));
 
-    if (loc.IsNull())
+    // This would not be needed if the Decode methed proprly decodes a null value.
+    if (loc.Value().locationName.empty() && loc.Value().floorNumber.IsNull() && loc.Value().areaType.IsNull())
     {
-        location.SetNull();
-        return CHIP_NO_ERROR;
+        loc.SetNull();
     }
 
-    memcpy((void *) location.Value().locationName.data(), loc.Value().locationName.data(), loc.Value().locationName.size());
-    location.Value().locationName.reduce_size(loc.Value().locationName.size());
-    location.Value().floorNumber = loc.Value().floorNumber;
-    location.Value().areaType    = loc.Value().areaType;
+    location = loc;
 
     return CHIP_NO_ERROR;
 }
 template <class ConfigClass>
 CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::SetDeviceLocation(DeviceLocatioType location)
 {
-    uint8_t locationData[kMaxDeviceLocationNameLength + sizeof(DeviceLocatioType)];
+    uint8_t locationData[app::Clusters::BasicInformation::kMaxDeviceLocationNameLength + sizeof(DeviceLocatioType)];
     MutableByteSpan locationSpan(locationData);
 
     TLV::TLVWriter tlvWriter;