add add some basic information cluster attributes to cmd line args to the reference app

examples/platform/linux/CommissionableInit.cpp

@@ -99,6 +99,35 @@ CHIP_ERROR InitConfigurationManager(ConfigurationManagerImpl & configManager, Li
  configManager.StoreProductId(options.payload.productID);
  }
 
+ if (options.vendorName.HasValue())
+ {
+ CharSpan vendor_name(options.vendorName.Value().c_str(), options.vendorName.Value().size());
+ VerifyOrDie(configManager.StoreVendorName(vendor_name) == CHIP_NO_ERROR);
+ }
+ if (options.productName.HasValue())
+ {
+ CharSpan product_name(options.productName.Value().c_str(), options.productName.Value().size());
+ VerifyOrDie(configManager.StoreProductName(product_name) == CHIP_NO_ERROR);
+ }
+ if (options.hardwareVersionString.HasValue())
+ {
+ CharSpan hardware_version_string(options.hardwareVersionString.Value().c_str(),
+ options.hardwareVersionString.Value().size());
+ VerifyOrDie(configManager.StoreHardwareVersionString(hardware_version_string) == CHIP_NO_ERROR);
+ }
+ if (options.softwareVersionString.HasValue())
+ {
+ CharSpan software_version_string(options.softwareVersionString.Value().c_str(),
+ options.softwareVersionString.Value().size());
+ VerifyOrDie(configManager.StoreSoftwareVersionString(software_version_string) == CHIP_NO_ERROR);
+ }
+
+ if (options.serialNumber.HasValue())
+ {
+ CharSpan serial_number(options.serialNumber.Value().c_str(), options.serialNumber.Value().size());
+ VerifyOrDie(configManager.StoreSerialNumber(serial_number) == CHIP_NO_ERROR);
+ }
+
  return CHIP_NO_ERROR;
 }
 

examples/platform/linux/Options.cpp

@@ -106,6 +106,12 @@ enum
 #if CHIP_WITH_NLFAULTINJECTION
  kDeviceOption_FaultInjection,
 #endif
+ kDeviceOption_VendorName = 0x1028,
+ kDeviceOption_ProductName = 0x1029,
+ kDeviceOption_HardwareVersionString = 0x102a,
+ kDeviceOption_SoftwareVersionString = 0x102b,
+ kDeviceOption_SerialNumber = 0x102c,
+
 };
 
 constexpr unsigned kAppUsageLength = 64;
@@ -124,6 +130,11 @@ OptionDef sDeviceOptionDefs[] = {
  { "version", kArgumentRequired, kDeviceOption_Version },
  { "vendor-id", kArgumentRequired, kDeviceOption_VendorID },
  { "product-id", kArgumentRequired, kDeviceOption_ProductID },
+ { "vendor-name", kArgumentRequired, kDeviceOption_VendorName },
+ { "product-name", kArgumentRequired, kDeviceOption_ProductName },
+ { "hardware-version-string", kArgumentRequired, kDeviceOption_HardwareVersionString },
+ { "software-version-string", kArgumentRequired, kDeviceOption_SoftwareVersionString },
+ { "serial-number", kArgumentRequired, kDeviceOption_SerialNumber },
  { "custom-flow", kArgumentRequired, kDeviceOption_CustomFlow },
  { "capabilities", kArgumentRequired, kDeviceOption_Capabilities },
  { "discriminator", kArgumentRequired, kDeviceOption_Discriminator },
@@ -204,6 +215,21 @@ const char * sDeviceOptionHelp =
  " --product-id <id>\n"
  " The Product ID is specified by vendor.\n"
  "\n"
+ " --vendor-name <name>\n"
+ " The vendor name specified by the vendor.\n"
+ "\n"
+ " --product-name <name>\n"
+ " The product name specified by vendor.\n"
+ "\n"
+ " --hardware-version-string <string>\n"
+ " The HardwareVersionString used in the basic information cluster.\n"
+ "\n"
+ " --software-version-string <string>\n"
+ " The SoftwareVersionString used in the basic information cluster.\n"
+ "\n"
+ " --serial-number <serial_number>\n"
+ " The serial number specified by vendor.\n"
+ "\n"
  " --custom-flow <Standard = 0 | UserActionRequired = 1 | Custom = 2>\n"
  " A 2-bit unsigned enumeration specifying manufacturer-specific custom flow options.\n"
  "\n"
@@ -589,6 +615,26 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier,
  break;
  }
 #endif
+ case kDeviceOption_VendorName:
+ LinuxDeviceOptions::GetInstance().vendorName.SetValue(std::string{ aValue });
+ break;
+
+ case kDeviceOption_ProductName:
+ LinuxDeviceOptions::GetInstance().productName.SetValue(std::string{ aValue });
+ break;
+
+ case kDeviceOption_HardwareVersionString:
+ LinuxDeviceOptions::GetInstance().hardwareVersionString.SetValue(std::string{ aValue });
+ break;
+
+ case kDeviceOption_SoftwareVersionString:
+ LinuxDeviceOptions::GetInstance().softwareVersionString.SetValue(std::string{ aValue });
+ break;
+
+ case kDeviceOption_SerialNumber:
+ LinuxDeviceOptions::GetInstance().serialNumber.SetValue(std::string{ aValue });
+ break;
+
  default:
  PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
  retval = false;

examples/platform/linux/Options.h

@@ -78,6 +78,12 @@ struct LinuxDeviceOptions
  int32_t subscriptionCapacity = CHIP_IM_MAX_NUM_SUBSCRIPTIONS;
  int32_t subscriptionResumptionRetryIntervalSec = -1;
 #endif
+ chip::Optional<std::string> vendorName;
+ chip::Optional<std::string> productName;
+ chip::Optional<std::string> hardwareVersionString;
+ chip::Optional<std::string> softwareVersionString;
+ chip::Optional<std::string> serialNumber;
+
  static LinuxDeviceOptions & GetInstance();
 };
 

src/include/platform/ConfigurationManager.h

@@ -114,7 +114,6 @@ class ConfigurationManager
 #endif
  virtual CHIP_ERROR GetRegulatoryLocation(uint8_t & location) = 0;
  virtual CHIP_ERROR GetCountryCode(char * buf, size_t bufSize, size_t & codeLen) = 0;
- virtual CHIP_ERROR StoreSerialNumber(const char * serialNum, size_t serialNumLen) = 0;
  virtual CHIP_ERROR StoreManufacturingDate(const char * mfgDate, size_t mfgDateLen) = 0;
  virtual CHIP_ERROR StoreSoftwareVersion(uint32_t softwareVer) = 0;
  virtual CHIP_ERROR StoreHardwareVersion(uint16_t hardwareVer) = 0;
@@ -133,6 +132,11 @@ class ConfigurationManager
  virtual CHIP_ERROR SetFailSafeArmed(bool val) = 0;
 
  virtual CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo) = 0;
+ virtual CHIP_ERROR StoreSerialNumber(CharSpan serialNumber) = 0;
+ virtual CHIP_ERROR StoreVendorName(CharSpan vendorName) = 0;
+ virtual CHIP_ERROR StoreProductName(CharSpan productName) = 0;
+ virtual CHIP_ERROR StoreHardwareVersionString(CharSpan hardwareVersionString) = 0;
+ virtual CHIP_ERROR StoreSoftwareVersionString(CharSpan softwareVersionString) = 0;
 
 #if CHIP_CONFIG_TEST
  virtual void RunUnitTests() = 0;

src/include/platform/internal/GenericConfigurationManagerImpl.h

@@ -68,7 +68,7 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
  CHIP_ERROR StoreSoftwareVersion(uint32_t softwareVer) override;
  CHIP_ERROR GetFirmwareBuildChipEpochTime(System::Clock::Seconds32 & buildTime) override;
  CHIP_ERROR SetFirmwareBuildChipEpochTime(System::Clock::Seconds32 buildTime) override;
- CHIP_ERROR StoreSerialNumber(const char * serialNum, size_t serialNumLen) override;
+ CHIP_ERROR StoreSerialNumber(CharSpan serialNumber) override;
  CHIP_ERROR GetPrimaryMACAddress(MutableByteSpan buf) override;
  CHIP_ERROR GetPrimaryWiFiMACAddress(uint8_t * buf) override;
  CHIP_ERROR GetPrimary802154MACAddress(uint8_t * buf) override;
@@ -103,6 +103,11 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
  CHIP_ERROR GetUniqueId(char * buf, size_t bufSize) override;
  CHIP_ERROR StoreUniqueId(const char * uniqueId, size_t uniqueIdLen) override;
  CHIP_ERROR GenerateUniqueId(char * buf, size_t bufSize) override;
+
+ CHIP_ERROR StoreVendorName(CharSpan vendorName) override;
+ CHIP_ERROR StoreProductName(CharSpan productName) override;
+ CHIP_ERROR StoreHardwareVersionString(CharSpan hardwareVersionString) override;
+ CHIP_ERROR StoreSoftwareVersionString(CharSpan softwareVersionString) override;
 #if CHIP_CONFIG_TEST
  void RunUnitTests() override;
 #endif

src/include/platform/internal/GenericConfigurationManagerImpl.ipp

@@ -351,15 +351,50 @@ CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSecondaryPairingHint
 template <class ConfigClass>
 CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSoftwareVersionString(char * buf, size_t bufSize)
 {
- ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
- strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING);
- return CHIP_NO_ERROR;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ size_t softwareVersionStringLen = 0; // without counting null-terminator
+
+ err = ReadConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, buf, bufSize, softwareVersionStringLen);
+
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ {
+ ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
+ memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING, sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING));
+
+ return CHIP_NO_ERROR;
+ }
+
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+ return err;
 }
 
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(const char * serialNum, size_t serialNumLen)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(CharSpan serialNumber)
+{
+ return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNumber.data(), serialNumber.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreVendorName(CharSpan vendorName)
+{
+
+ return WriteConfigValueStr(ConfigClass::kConfigKey_VendorName, vendorName.data(), vendorName.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreProductName(CharSpan productName)
+{
+ return WriteConfigValueStr(ConfigClass::kConfigKey_ProductName, productName.data(), productName.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreHardwareVersionString(CharSpan hardwareVersionString)
+{
+ return WriteConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, hardwareVersionString.data(),
+ hardwareVersionString.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSoftwareVersionString(CharSpan softwareVersionString)
 {
- return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNum, serialNumLen);
+ return WriteConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, softwareVersionString.data(),
+ softwareVersionString.size());
 }
 
 template <class ConfigClass>

src/include/platform/internal/GenericDeviceInstanceInfoProvider.ipp

@@ -38,18 +38,41 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductId(uint16_t
 template <class ConfigClass>
 CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetVendorName(char * buf, size_t bufSize)
 {
- ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
- strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME);
- return CHIP_NO_ERROR;
+ ChipError err = CHIP_NO_ERROR;
+ size_t vendorNameLen = 0; // without counting null-terminator
+
+ err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_VendorName, buf, bufSize, vendorNameLen);
+
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ {
+ ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
+ memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME, sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME));
+ err = CHIP_NO_ERROR;
+ }
+
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+
+ return err;
 }
 
 template <class ConfigClass>
 CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductName(char * buf, size_t bufSize)
 {
- ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
- strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME);
+ ChipError err = CHIP_NO_ERROR;
+ size_t productNameLen = 0; // without counting null-terminator
 
- return CHIP_NO_ERROR;
+ err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_ProductName, buf, bufSize, productNameLen);
+
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ {
+ ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
+ memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME, sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME));
+ err = CHIP_NO_ERROR;
+ }
+
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+
+ return err;
 }
 
 template <class ConfigClass>
@@ -96,19 +119,15 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetSerialNumber(char
 
  err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_SerialNum, buf, bufSize, serialNumLen);
 
-#ifdef CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER
- if (CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
  {
  ReturnErrorCodeIf(sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER) > bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
  memcpy(buf, CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER, sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER));
- serialNumLen = sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER) - 1;
- err  = CHIP_NO_ERROR;
+
+ err = CHIP_NO_ERROR;
  }
-#endif // CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER
- ReturnErrorOnFailure(err);
 
- ReturnErrorCodeIf(serialNumLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
- ReturnErrorCodeIf(buf[serialNumLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
 
  return err;
 }
@@ -176,9 +195,23 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersion(ui
 template <class ConfigClass>
 CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersionString(char * buf, size_t bufSize)
 {
- ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
- strcpy(buf, CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING);
- return CHIP_NO_ERROR;
+ ChipError err = CHIP_NO_ERROR;
+ size_t hardwareVersionStringLen = 0; // without counting null-terminator
+
+ err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, buf, bufSize,
+ hardwareVersionStringLen);
+
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ {
+ ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
+ memcpy(buf, CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING,
+ sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING));
+ err = CHIP_NO_ERROR;
+ }
+
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+
+ return err;
 }
 
 template <class ConfigClass>

src/platform/ASR/ASRConfig.cpp

@@ -80,6 +80,11 @@ const ASRConfig::Key ASRConfig::kConfigKey_WiFiSecurity = { kConfigNamespa
 const ASRConfig::Key ASRConfig::kConfigKey_WiFiMode = { kConfigNamespace_ChipConfig, "wifimode" };
 const ASRConfig::Key ASRConfig::kConfigKey_UniqueId = { kConfigNamespace_ChipConfig, "unique-id" };
 
+const ASRConfig::Key ASRConfig::kConfigKey_VendorName = { kConfigNamespace_ChipConfig, "vendor-name" };
+const ASRConfig::Key ASRConfig::kConfigKey_ProductName = { kConfigNamespace_ChipConfig, "product-name" };
+const ASRConfig::Key ASRConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipConfig, "hardware-version-string" };
+const ASRConfig::Key ASRConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipConfig, "software-version-string" };
+
 // Keys stored in the Chip-counters namespace
 const ASRConfig::Key ASRConfig::kCounterKey_RebootCount = { kConfigNamespace_ChipCounters, "reboot-count" };
 const ASRConfig::Key ASRConfig::kCounterKey_UpTime = { kConfigNamespace_ChipCounters, "up-time" };

src/platform/ASR/ASRConfig.h

@@ -91,6 +91,11 @@ class ASRConfig
  static const Key kCounterKey_UpTime;
  static const Key kCounterKey_TotalOperationalHours;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  // Config value accessors.
  static CHIP_ERROR ReadConfigValue(Key key, bool & val);
  static CHIP_ERROR ReadConfigValue(Key key, uint32_t & val);

src/platform/Ameba/AmebaConfig.cpp

@@ -79,6 +79,11 @@ const AmebaConfig::Key AmebaConfig::kConfigKey_RegulatoryLocation = { k
 const AmebaConfig::Key AmebaConfig::kConfigKey_LocationCapability = { kConfigNamespace_ChipConfig, "location-capability" };
 const AmebaConfig::Key AmebaConfig::kConfigKey_CountryCode = { kConfigNamespace_ChipConfig, "country-code" };
 
+const AmebaConfig::Key AmebaConfig::kConfigKey_VendorName = { kConfigNamespace_ChipConfig, "vendor-name" };
+const AmebaConfig::Key AmebaConfig::kConfigKey_ProductName = { kConfigNamespace_ChipConfig, "product-name" };
+const AmebaConfig::Key AmebaConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipConfig, "hardware-version-string" };
+const AmebaConfig::Key AmebaConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipConfig, "software-version-string" };
+
 // Keys stored in the Chip-counters namespace
 const AmebaConfig::Key AmebaConfig::kCounterKey_RebootCount = { kConfigNamespace_ChipCounters, "reboot-count" };
 const AmebaConfig::Key AmebaConfig::kCounterKey_UpTime = { kConfigNamespace_ChipCounters, "up-time" };

src/platform/Ameba/AmebaConfig.h

@@ -74,6 +74,11 @@ class AmebaConfig
  static const Key kCounterKey_TotalOperationalHours;
  static const Key kCounterKey_BootReason;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  // Config value accessors.
  static CHIP_ERROR ReadConfigValue(Key key, bool & val);
  static CHIP_ERROR ReadConfigValue(Key key, uint32_t & val);

src/platform/Beken/BekenConfig.cpp

@@ -79,6 +79,11 @@ const BekenConfig::Key BekenConfig::kConfigKey_RegulatoryLocation = { k
 const BekenConfig::Key BekenConfig::kConfigKey_CountryCode = { kConfigNamespace_ChipConfig, "country-code" };
 const BekenConfig::Key BekenConfig::kConfigKey_Breadcrumb = { kConfigNamespace_ChipConfig, "breadcrumb" };
 
+const BekenConfig::Key BekenConfig::kConfigKey_VendorName = { kConfigNamespace_ChipConfig, "vendor-name" };
+const BekenConfig::Key BekenConfig::kConfigKey_ProductName = { kConfigNamespace_ChipConfig, "product-name" };
+const BekenConfig::Key BekenConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipConfig, "hardware-version-string" };
+const BekenConfig::Key BekenConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipConfig, "software-version-string" };
+
 // Keys stored in the Chip-counters namespace
 const BekenConfig::Key BekenConfig::kCounterKey_RebootCount = { kConfigNamespace_ChipCounters, "reboot-count" };
 const BekenConfig::Key BekenConfig::kCounterKey_UpTime = { kConfigNamespace_ChipCounters, "up-time" };

src/platform/Beken/BekenConfig.h

@@ -74,6 +74,11 @@ class BekenConfig
  static const Key kCounterKey_TotalOperationalHours;
  static const Key kCounterKey_BootReason;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  static const char kGroupKeyNamePrefix[];
 
  // Config value accessors.