Configure attribute

Michail-Antropov · Michail-Antropov · commit d6598924665a · 2024-07-02T13:39:22.000+03:00
diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap
@@ -14240,6 +14240,38 @@
           "side": "server",
           "enabled": 1,
           "attributes": [
+            {
+              "name": "CalendarID",
+              "code": 0,
+              "mfgCode": null,
+              "side": "server",
+              "type": "int32u",
+              "included": 1,
+              "storageOption": "External",
+              "singleton": 0,
+              "bounded": 0,
+              "defaultValue": null,
+              "reportable": 1,
+              "minInterval": 1,
+              "maxInterval": 65534,
+              "reportableChange": 1
+            },
+            {
+              "name": "Name",
+              "code": 1,
+              "mfgCode": null,
+              "side": "server",
+              "type": "char_string",
+              "included": 1,
+              "storageOption": "External",
+              "singleton": 1,
+              "bounded": 0,
+              "defaultValue": null,
+              "reportable": 1,
+              "minInterval": 0,
+              "maxInterval": 65344,
+              "reportableChange": 1
+            },
             {
               "name": "FeatureMap",
               "code": 65532,
@@ -21789,6 +21821,54 @@
           "side": "server",
           "enabled": 1,
           "attributes": [
+            {
+              "name": "MeterType",
+              "code": 0,
+              "mfgCode": null,
+              "side": "server",
+              "type": "MeterTypeEnum",
+              "included": 1,
+              "storageOption": "External",
+              "singleton": 0,
+              "bounded": 0,
+              "defaultValue": null,
+              "reportable": 1,
+              "minInterval": 1,
+              "maxInterval": 65534,
+              "reportableChange": 1
+            },
+            {
+              "name": "UtilityName",
+              "code": 1,
+              "mfgCode": null,
+              "side": "server",
+              "type": "char_string",
+              "included": 1,
+              "storageOption": "External",
+              "singleton": 1,
+              "bounded": 0,
+              "defaultValue": null,
+              "reportable": 1,
+              "minInterval": 0,
+              "maxInterval": 65344,
+              "reportableChange": 1
+            },
+            {
+              "name": "PointOfDelivery",
+              "code": 2,
+              "mfgCode": null,
+              "side": "server",
+              "type": "char_string",
+              "included": 1,
+              "storageOption": "External",
+              "singleton": 1,
+              "bounded": 0,
+              "defaultValue": null,
+              "reportable": 1,
+              "minInterval": 0,
+              "maxInterval": 65344,
+              "reportableChange": 1
+            },
             {
               "name": "FeatureMap",
               "code": 65532,
diff --git a/examples/all-clusters-app/all-clusters-common/src/meter-identification-stub.cpp b/examples/all-clusters-app/all-clusters-common/src/meter-identification-stub.cpp
@@ -34,6 +34,8 @@ void emberAfMeterIdentificationClusterInitCallback(chip::EndpointId endpointId)
     gMIDelegate = std::make_unique<MeterIdentificationDelegate>();
     if (gMIDelegate)
     {
+        gMIDelegate->Init();
+        
         gMIInstance = std::make_unique<MeterIdentificationInstance>(endpointId, *gMIDelegate,
                                                                     BitMask<Feature, uint32_t>(Feature::kPowerThreshold));
 
diff --git a/examples/energy-management-app/energy-management-common/include/MeterIdentificationDelegate.h b/examples/energy-management-app/energy-management-common/include/MeterIdentificationDelegate.h
@@ -32,6 +32,8 @@ class MeterIdentificationDelegate : public MeterIdentification::Delegate
 public:
     ~MeterIdentificationDelegate() = default;
 
+    void Init();
+
     CHIP_ERROR LoadJson(Json::Value & root);
 
     // Attribute Accessors
@@ -44,8 +46,8 @@ class MeterIdentificationDelegate : public MeterIdentification::Delegate
 
     // Internal Application API to set attribute values
     CHIP_ERROR SetMeterType(DataModel::Nullable<MeterTypeEnum>);
-    CHIP_ERROR SetUtilityName(CharSpan & value);
-    CHIP_ERROR SetPointOfDelivery(CharSpan & value);
+    CHIP_ERROR SetUtilityName(CharSpan value);
+    CHIP_ERROR SetPointOfDelivery(CharSpan value);
     CHIP_ERROR SetPowerThreshold(DataModel::Nullable<uint64_t>);
     CHIP_ERROR SetPowerThresholdSource(DataModel::Nullable<PowerThresholdSourceEnum>);
 
diff --git a/examples/energy-management-app/energy-management-common/src/MeterIdentificationDelegate.cpp b/examples/energy-management-app/energy-management-common/src/MeterIdentificationDelegate.cpp
@@ -43,52 +43,55 @@ void MeterIdentificationInstance::Shutdown()
 
 // --------------- Internal Attribute Set APIs
 
+void MeterIdentificationDelegate::Init()
+{
+    ChipLogProgress(Zcl, "MeterIdentificationDelegate::Init");
+
+    SetMeterType(MeterTypeEnum::kPrivate);
+    SetUtilityName(CharSpan::fromCharString("Test Utility Name"));
+    SetPointOfDelivery(CharSpan::fromCharString("Test PointOfDelivery"));
+    SetPowerThreshold(100);
+    SetPowerThresholdSource(PowerThresholdSourceEnum::kEquipment);
+}
+
 CHIP_ERROR MeterIdentificationDelegate::LoadJson(Json::Value & root)
 {
     Json::Value value = root.get("MeterType", Json::Value());
     if (!value.empty())
     {
         if(value.isInt())
         {
-            mMeterType.SetNonNull(static_cast<MeterTypeEnum>(value.asInt()));
+            SetMeterType(static_cast<MeterTypeEnum>(value.asInt()));
         }
         else
         {
-            mMeterType.SetNull();
+            SetMeterType(std::nullopt);
         }
     }
 
     value = root.get("UtilityName", Json::Value());
     if (!value.empty())
     {
-        chip::Platform::MemoryFree((void*)mUtilityName.data());
         if(value.isString())
         {
-            size_t len = value.asString().size()+1;
-            char *str = (char*)chip::Platform::MemoryAlloc(len);
-            memcpy(str, value.asCString(), len);
-            mUtilityName = CharSpan(str, len);
+            SetUtilityName(CharSpan::fromCharString(value.asCString()));
         }
         else
         {
-            mUtilityName = CharSpan();
+            SetUtilityName(CharSpan());
         }
     }
 
     value = root.get("PointOfDelivery", Json::Value());
     if (!value.empty())
     {
-        chip::Platform::MemoryFree((void*)mPointOfDelivery.data());
         if(value.isString())
         {
-            size_t len = value.asString().size()+1;
-            char *str = (char*)chip::Platform::MemoryAlloc(len);
-            memcpy(str, value.asCString(), len);
-            mPointOfDelivery = CharSpan(str, len);
+            SetPointOfDelivery(CharSpan::fromCharString(value.asCString()));
         }
         else
         {
-            mPointOfDelivery = CharSpan();
+            SetPointOfDelivery(CharSpan());
         }
     }
 
@@ -97,11 +100,11 @@ CHIP_ERROR MeterIdentificationDelegate::LoadJson(Json::Value & root)
     {
         if(value.isInt())
         {
-            mPowerThreshold.SetNonNull(value.asInt());
+            SetPowerThreshold(value.asInt());
         }
         else
         {
-            mPowerThreshold.SetNull();
+            SetPowerThreshold(std::nullopt);
         }
     }
 
@@ -110,11 +113,11 @@ CHIP_ERROR MeterIdentificationDelegate::LoadJson(Json::Value & root)
     {
         if(value.isInt())
         {
-            mPowerThresholdSource.SetNonNull(static_cast<PowerThresholdSourceEnum>(value.asInt()));
+            SetPowerThresholdSource(static_cast<PowerThresholdSourceEnum>(value.asInt()));
         }
         else
         {
-            mPowerThresholdSource.SetNull();
+            SetPowerThresholdSource(std::nullopt);
         }
     }
 
@@ -128,17 +131,29 @@ CHIP_ERROR MeterIdentificationDelegate::SetMeterType(DataModel::Nullable<MeterTy
     mMeterType = newValue;
     // if (oldValue != newValue)
     //{
-    //     MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, MeterType::Id);
+         MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, MeterType::Id);
     // }
 
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR MeterIdentificationDelegate::SetUtilityName(CharSpan & newValue)
+CHIP_ERROR MeterIdentificationDelegate::SetUtilityName(CharSpan newValue)
 {
     // CharSpan oldValue = mUtilityName;
 
-    mUtilityName = newValue;
+    chip::Platform::MemoryFree((void*)mUtilityName.data());
+    if (!newValue.empty())
+    {
+        size_t len = newValue.size();
+        char *str = (char*)chip::Platform::MemoryAlloc(len);
+        memcpy(str, newValue.data(), len);
+        mUtilityName = CharSpan(str, len);
+    }
+    else
+    {
+        mUtilityName = CharSpan();
+    }
+
     // if (!oldValue.data_equal(newValue))
     //{
     //     MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, UtilityName::Id);
@@ -147,11 +162,23 @@ CHIP_ERROR MeterIdentificationDelegate::SetUtilityName(CharSpan & newValue)
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR MeterIdentificationDelegate::SetPointOfDelivery(CharSpan & newValue)
+CHIP_ERROR MeterIdentificationDelegate::SetPointOfDelivery(CharSpan newValue)
 {
     // CharSpan oldValue = mPointOfDelivery;
 
-    mPointOfDelivery = newValue;
+    chip::Platform::MemoryFree((void*)mPointOfDelivery.data());
+    if (!newValue.empty())
+    {
+        size_t len = newValue.size();
+        char *str = (char*)chip::Platform::MemoryAlloc(len);
+        memcpy(str, newValue.data(), len);
+        mPointOfDelivery = CharSpan(str, len);
+    }
+    else
+    {
+        mPointOfDelivery = CharSpan();
+    }
+
     // if (!oldValue.data_equal(newValue))
     //{
     //     MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, PointOfDelivery::Id);
diff --git a/src/app/clusters/meter-identification-server/meter-identification-server.cpp b/src/app/clusters/meter-identification-server/meter-identification-server.cpp
@@ -64,6 +64,7 @@ bool Instance::HasFeature(Feature aFeature) const
 // AttributeAccessInterface
 CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
 {
+    ChipLogProgress(Zcl, "Meter Ind read attr %d", aPath.mAttributeId);
     switch (aPath.mAttributeId)
     {
     case FeatureMap::Id:
@@ -114,4 +115,4 @@ CHIP_ERROR Instance::Write(const ConcreteDataAttributePath & aPath, AttributeVal
 // -----------------------------------------------------------------------------
 // Plugin initialization
 
-void MatterMeterIdentificationPluginServerInitCallback() {}
+void MatterMeterIdentificationPluginServerInitCallback() {}

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,8 @@ void emberAfMeterIdentificationClusterInitCallback(chip::EndpointId endpointId)`
`34`	`34`	`gMIDelegate = std::make_unique<MeterIdentificationDelegate>();`
`35`	`35`	`if (gMIDelegate)`
`36`	`36`	`{`
	`37`	`+ gMIDelegate->Init();`
	`38`	`+`
`37`	`39`	`gMIInstance = std::make_unique<MeterIdentificationInstance>(endpointId, *gMIDelegate,`
`38`	`40`	`BitMask<Feature, uint32_t>(Feature::kPowerThreshold));`
`39`	`41`
Original file line number	Diff line number	Diff line change
`@@ -43,52 +43,55 @@ void MeterIdentificationInstance::Shutdown()`
`43`	`43`
`44`	`44`	`// --------------- Internal Attribute Set APIs`
`45`	`45`
	`46`	`+void MeterIdentificationDelegate::Init()`
	`47`	`+{`
	`48`	`+ ChipLogProgress(Zcl, "MeterIdentificationDelegate::Init");`
	`49`	`+`
	`50`	`+ SetMeterType(MeterTypeEnum::kPrivate);`
	`51`	`+ SetUtilityName(CharSpan::fromCharString("Test Utility Name"));`
	`52`	`+ SetPointOfDelivery(CharSpan::fromCharString("Test PointOfDelivery"));`
	`53`	`+ SetPowerThreshold(100);`
	`54`	`+ SetPowerThresholdSource(PowerThresholdSourceEnum::kEquipment);`
	`55`	`+}`
	`56`	`+`
`46`	`57`	`CHIP_ERROR MeterIdentificationDelegate::LoadJson(Json::Value & root)`
`47`	`58`	`{`
`48`	`59`	`Json::Value value = root.get("MeterType", Json::Value());`
`49`	`60`	`if (!value.empty())`
`50`	`61`	`{`
`51`	`62`	`if(value.isInt())`
`52`	`63`	`{`
`53`		`- mMeterType.SetNonNull(static_cast<MeterTypeEnum>(value.asInt()));`
	`64`	`+ SetMeterType(static_cast<MeterTypeEnum>(value.asInt()));`
`54`	`65`	`}`
`55`	`66`	`else`
`56`	`67`	`{`
`57`		`- mMeterType.SetNull();`
	`68`	`+ SetMeterType(std::nullopt);`
`58`	`69`	`}`
`59`	`70`	`}`
`60`	`71`
`61`	`72`	`value = root.get("UtilityName", Json::Value());`
`62`	`73`	`if (!value.empty())`
`63`	`74`	`{`
`64`		`- chip::Platform::MemoryFree((void*)mUtilityName.data());`
`65`	`75`	`if(value.isString())`
`66`	`76`	`{`
`67`		`- size_t len = value.asString().size()+1;`
`68`		`- char str = (char)chip::Platform::MemoryAlloc(len);`
`69`		`- memcpy(str, value.asCString(), len);`
`70`		`- mUtilityName = CharSpan(str, len);`
	`77`	`+ SetUtilityName(CharSpan::fromCharString(value.asCString()));`
`71`	`78`	`}`
`72`	`79`	`else`
`73`	`80`	`{`
`74`		`- mUtilityName = CharSpan();`
	`81`	`+ SetUtilityName(CharSpan());`
`75`	`82`	`}`
`76`	`83`	`}`
`77`	`84`
`78`	`85`	`value = root.get("PointOfDelivery", Json::Value());`
`79`	`86`	`if (!value.empty())`
`80`	`87`	`{`
`81`		`- chip::Platform::MemoryFree((void*)mPointOfDelivery.data());`
`82`	`88`	`if(value.isString())`
`83`	`89`	`{`
`84`		`- size_t len = value.asString().size()+1;`
`85`		`- char str = (char)chip::Platform::MemoryAlloc(len);`
`86`		`- memcpy(str, value.asCString(), len);`
`87`		`- mPointOfDelivery = CharSpan(str, len);`
	`90`	`+ SetPointOfDelivery(CharSpan::fromCharString(value.asCString()));`
`88`	`91`	`}`
`89`	`92`	`else`
`90`	`93`	`{`
`91`		`- mPointOfDelivery = CharSpan();`
	`94`	`+ SetPointOfDelivery(CharSpan());`
`92`	`95`	`}`
`93`	`96`	`}`
`94`	`97`
`@@ -97,11 +100,11 @@ CHIP_ERROR MeterIdentificationDelegate::LoadJson(Json::Value & root)`
`97`	`100`	`{`
`98`	`101`	`if(value.isInt())`
`99`	`102`	`{`
`100`		`- mPowerThreshold.SetNonNull(value.asInt());`
	`103`	`+ SetPowerThreshold(value.asInt());`
`101`	`104`	`}`
`102`	`105`	`else`
`103`	`106`	`{`
`104`		`- mPowerThreshold.SetNull();`
	`107`	`+ SetPowerThreshold(std::nullopt);`
`105`	`108`	`}`
`106`	`109`	`}`
`107`	`110`
`@@ -110,11 +113,11 @@ CHIP_ERROR MeterIdentificationDelegate::LoadJson(Json::Value & root)`
`110`	`113`	`{`
`111`	`114`	`if(value.isInt())`
`112`	`115`	`{`
`113`		`- mPowerThresholdSource.SetNonNull(static_cast<PowerThresholdSourceEnum>(value.asInt()));`
	`116`	`+ SetPowerThresholdSource(static_cast<PowerThresholdSourceEnum>(value.asInt()));`
`114`	`117`	`}`
`115`	`118`	`else`
`116`	`119`	`{`
`117`		`- mPowerThresholdSource.SetNull();`
	`120`	`+ SetPowerThresholdSource(std::nullopt);`
`118`	`121`	`}`
`119`	`122`	`}`
`120`	`123`
`@@ -128,17 +131,29 @@ CHIP_ERROR MeterIdentificationDelegate::SetMeterType(DataModel::Nullable<MeterTy`
`128`	`131`	`mMeterType = newValue;`
`129`	`132`	`// if (oldValue != newValue)`
`130`	`133`	`//{`
`131`		`- // MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, MeterType::Id);`
	`134`	`+ MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, MeterType::Id);`
`132`	`135`	`// }`
`133`	`136`
`134`	`137`	`return CHIP_NO_ERROR;`
`135`	`138`	`}`
`136`	`139`
`137`		`-CHIP_ERROR MeterIdentificationDelegate::SetUtilityName(CharSpan & newValue)`
	`140`	`+CHIP_ERROR MeterIdentificationDelegate::SetUtilityName(CharSpan newValue)`
`138`	`141`	`{`
`139`	`142`	`// CharSpan oldValue = mUtilityName;`
`140`	`143`
`141`		`- mUtilityName = newValue;`
	`144`	`+ chip::Platform::MemoryFree((void*)mUtilityName.data());`
	`145`	`+ if (!newValue.empty())`
	`146`	`+ {`
	`147`	`+ size_t len = newValue.size();`
	`148`	`+ char str = (char)chip::Platform::MemoryAlloc(len);`
	`149`	`+ memcpy(str, newValue.data(), len);`
	`150`	`+ mUtilityName = CharSpan(str, len);`
	`151`	`+ }`
	`152`	`+ else`
	`153`	`+ {`
	`154`	`+ mUtilityName = CharSpan();`
	`155`	`+ }`
	`156`	`+`
`142`	`157`	`// if (!oldValue.data_equal(newValue))`
`143`	`158`	`//{`
`144`	`159`	`// MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, UtilityName::Id);`
`@@ -147,11 +162,23 @@ CHIP_ERROR MeterIdentificationDelegate::SetUtilityName(CharSpan & newValue)`
`147`	`162`	`return CHIP_NO_ERROR;`
`148`	`163`	`}`
`149`	`164`
`150`		`-CHIP_ERROR MeterIdentificationDelegate::SetPointOfDelivery(CharSpan & newValue)`
	`165`	`+CHIP_ERROR MeterIdentificationDelegate::SetPointOfDelivery(CharSpan newValue)`
`151`	`166`	`{`
`152`	`167`	`// CharSpan oldValue = mPointOfDelivery;`
`153`	`168`
`154`		`- mPointOfDelivery = newValue;`
	`169`	`+ chip::Platform::MemoryFree((void*)mPointOfDelivery.data());`
	`170`	`+ if (!newValue.empty())`
	`171`	`+ {`
	`172`	`+ size_t len = newValue.size();`
	`173`	`+ char str = (char)chip::Platform::MemoryAlloc(len);`
	`174`	`+ memcpy(str, newValue.data(), len);`
	`175`	`+ mPointOfDelivery = CharSpan(str, len);`
	`176`	`+ }`
	`177`	`+ else`
	`178`	`+ {`
	`179`	`+ mPointOfDelivery = CharSpan();`
	`180`	`+ }`
	`181`	`+`
`155`	`182`	`// if (!oldValue.data_equal(newValue))`
`156`	`183`	`//{`
`157`	`184`	`// MatterReportingAttributeChangeCallback(mEndpointId, MeterIdentification::Id, PointOfDelivery::Id);`
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,7 @@ bool Instance::HasFeature(Feature aFeature) const`
`64`	`64`	`// AttributeAccessInterface`
`65`	`65`	`CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)`
`66`	`66`	`{`
	`67`	`+ ChipLogProgress(Zcl, "Meter Ind read attr %d", aPath.mAttributeId);`
`67`	`68`	`switch (aPath.mAttributeId)`
`68`	`69`	`{`
`69`	`70`	`case FeatureMap::Id:`
`@@ -114,4 +115,4 @@ CHIP_ERROR Instance::Write(const ConcreteDataAttributePath & aPath, AttributeVal`
`114`	`115`	`// -----------------------------------------------------------------------------`
`115`	`116`	`// Plugin initialization`
`116`	`117`
`117`		`-void MatterMeterIdentificationPluginServerInitCallback() {}`
	`118`	`+void MatterMeterIdentificationPluginServerInitCallback() {}`