Add a config variable for disabling platform KVS. (#17777)

bzbarsky-apple · pull[bot] · commit 2632405461f9 · 2024-02-17T19:46:08.000Z
Implement support for doing that on Darwin, and enable that support
when building the Darwin framework, via either Xcode or
chip-tool-darwin.
diff --git a/examples/chip-tool-darwin/.gn b/examples/chip-tool-darwin/.gn
@@ -22,4 +22,6 @@ check_system_includes = true
 
 default_args = {
   import("//args.gni")
+
+  chip_disable_platform_kvs = true
 }
diff --git a/examples/chip-tool-darwin/commands/common/CHIPCommandBridge.mm b/examples/chip-tool-darwin/commands/common/CHIPCommandBridge.mm
@@ -43,7 +43,6 @@
     auto params = [[MatterControllerFactoryParams alloc] initWithStorage:storage];
     params.port = @(kListenPort);
     params.startServer = YES;
-    params.kvsPath = @("/tmp/chip_kvs_darwin");
 
     if ([factory startup:params] == NO) {
         ChipLogError(chipTool, "Controller factory startup failed");
diff --git a/src/darwin/Framework/CHIP/MatterControllerFactory.h b/src/darwin/Framework/CHIP/MatterControllerFactory.h
@@ -56,11 +56,6 @@ NS_ASSUME_NONNULL_BEGIN
  * connections.  Defaults to NO.
  */
 @property (nonatomic) BOOL startServer;
-/*
- * Path to a file to use for backing our KVS storage.  This should not
- * be used, generally; it will be removed soon.  Defaults to nil.
- */
-@property (strong, nonatomic, nullable) NSString * kvsPath;
 
 - (instancetype)init NS_UNAVAILABLE;
 - (instancetype)initWithStorage:(id<CHIPPersistentStorageDelegate>)storageDelegate;
diff --git a/src/darwin/Framework/CHIP/MatterControllerFactory.mm b/src/darwin/Framework/CHIP/MatterControllerFactory.mm
@@ -41,7 +41,6 @@
 static NSString * const kErrorAttestationTrustStoreInit = @"Init failure while creating the attestation trust store";
 static NSString * const kInfoFactoryShutdown = @"Shutting down the Matter controller factory";
 static NSString * const kErrorGroupProviderInit = @"Init failure while initializing group data provider";
-static NSString * const kErrorKVSInit = @"Init Key Value Store failure";
 static NSString * const kErrorControllersInit = @"Init controllers array failure";
 static NSString * const kErrorControllerFactoryInit = @"Init failure while initializing controller factory";
 
@@ -179,15 +178,6 @@ - (BOOL)startup:(MatterControllerFactoryParams *)startupParams
 
         [CHIPControllerAccessControl init];
 
-        if (startupParams.kvsPath != nil) {
-            // TODO: We should stop needing a KeyValueStoreManager on the client side, then remove this code.
-            CHIP_ERROR errorCode = DeviceLayer::PersistedStorage::KeyValueStoreMgrImpl().Init([startupParams.kvsPath UTF8String]);
-            if (errorCode != CHIP_NO_ERROR) {
-                CHIP_LOG_ERROR("Error: %@", kErrorKVSInit);
-                return;
-            }
-        }
-
         _persistentStorageDelegateBridge = new CHIPPersistentStorageDelegateBridge(startupParams.storageDelegate);
         if (_persistentStorageDelegateBridge == nil) {
             CHIP_LOG_ERROR("Error: %@", kErrorPersistentStorageInit);
@@ -468,7 +458,6 @@ - (instancetype)initWithStorage:(id<CHIPPersistentStorageDelegate>)storageDelega
     _paaCerts = nil;
     _port = nil;
     _startServer = NO;
-    _kvsPath = nil;
 
     return self;
 }
diff --git a/src/darwin/Framework/chip_xcode_build_connector.sh b/src/darwin/Framework/chip_xcode_build_connector.sh
@@ -96,6 +96,7 @@ declare -a args=(
     'chip_crypto="mbedtls"'
     'chip_build_tools=false'
     'chip_build_tests=false'
+    'chip_disable_platform_kvs=true'
     'target_cpu="'"$target_cpu"'"'
     'target_defines='"$target_defines"
     'target_cflags=['"$target_cflags"']'
diff --git a/src/platform/BUILD.gn b/src/platform/BUILD.gn
@@ -108,6 +108,7 @@ if (chip_device_platform != "none" && chip_device_platform != "external") {
       "CHIP_STACK_LOCK_TRACKING_ERROR_FATAL=${chip_stack_lock_tracking_fatal}",
       "CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING=${chip_enable_additional_data_advertising}",
       "CHIP_DEVICE_CONFIG_RUN_AS_ROOT=${chip_device_config_run_as_root}",
+      "CHIP_DISABLE_PLATFORM_KVS=${chip_disable_platform_kvs}",
     ]
 
     if (chip_device_platform == "linux" || chip_device_platform == "darwin" ||
diff --git a/src/platform/Darwin/BUILD.gn b/src/platform/Darwin/BUILD.gn
@@ -55,8 +55,6 @@ static_library("Darwin") {
     "DnssdImpl.cpp",
     "DnssdImpl.h",
     "InetPlatformConfig.h",
-    "KeyValueStoreManagerImpl.h",
-    "KeyValueStoreManagerImpl.mm",
     "Logging.cpp",
     "MdnsError.cpp",
     "MdnsError.h",
@@ -68,6 +66,13 @@ static_library("Darwin") {
     "SystemTimeSupport.cpp",
   ]
 
+  if (chip_disable_platform_kvs == false) {
+    sources += [
+      "KeyValueStoreManagerImpl.h",
+      "KeyValueStoreManagerImpl.mm",
+    ]
+  }
+
   deps = [
     "${chip_root}/src/lib/dnssd:platform_header",
     "${chip_root}/src/setup_payload",
diff --git a/src/platform/Darwin/ConfigurationManagerImpl.cpp b/src/platform/Darwin/ConfigurationManagerImpl.cpp
@@ -151,6 +151,9 @@ ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance()
 
 CHIP_ERROR ConfigurationManagerImpl::Init()
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_NO_ERROR;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     // Initialize the generic implementation base class.
     ReturnErrorOnFailure(Internal::GenericConfigurationManagerImpl<PosixConfig>::Init());
 
@@ -199,6 +202,7 @@ CHIP_ERROR ConfigurationManagerImpl::Init()
     }
 
     return CHIP_NO_ERROR;
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetPrimaryWiFiMACAddress(uint8_t * buf)
@@ -232,56 +236,99 @@ void ConfigurationManagerImpl::InitiateFactoryReset()
 
 CHIP_ERROR ConfigurationManagerImpl::GetVendorId(uint16_t & vendorId)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return ReadConfigValue(PosixConfig::kConfigKey_VendorId, vendorId);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetProductId(uint16_t & productId)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return ReadConfigValue(PosixConfig::kConfigKey_ProductId, productId);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::StoreVendorId(uint16_t vendorId)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return WriteConfigValue(PosixConfig::kConfigKey_VendorId, vendorId);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::StoreProductId(uint16_t productId)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return WriteConfigValue(PosixConfig::kConfigKey_ProductId, productId);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetRebootCount(uint32_t & rebootCount)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return ReadConfigValue(PosixConfig::kCounterKey_RebootCount, rebootCount);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::StoreRebootCount(uint32_t rebootCount)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return WriteConfigValue(PosixConfig::kCounterKey_RebootCount, rebootCount);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return ReadConfigValue(PosixConfig::kCounterKey_TotalOperationalHours, totalOperationalHours);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::StoreTotalOperationalHours(uint32_t totalOperationalHours)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return WriteConfigValue(PosixConfig::kCounterKey_TotalOperationalHours, totalOperationalHours);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetBootReason(uint32_t & bootReason)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return ReadConfigValue(PosixConfig::kCounterKey_BootReason, bootReason);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::StoreBootReason(uint32_t bootReason)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return WriteConfigValue(PosixConfig::kCounterKey_BootReason, bootReason);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetRegulatoryLocation(uint8_t & location)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     uint32_t value = 0;
 
     CHIP_ERROR err = ReadConfigValue(PosixConfig::kConfigKey_RegulatoryLocation, value);
@@ -293,10 +340,14 @@ CHIP_ERROR ConfigurationManagerImpl::GetRegulatoryLocation(uint8_t & location)
     }
 
     return err;
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::GetLocationCapability(uint8_t & location)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     uint32_t value = 0;
 
     CHIP_ERROR err = ReadConfigValue(PosixConfig::kConfigKey_LocationCapability, value);
@@ -308,10 +359,14 @@ CHIP_ERROR ConfigurationManagerImpl::GetLocationCapability(uint8_t & location)
     }
 
     return err;
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     PosixConfig::Key configKey{ PosixConfig::kConfigNamespace_ChipCounters, key };
 
     CHIP_ERROR err = ReadConfigValue(configKey, value);
@@ -320,82 +375,143 @@ CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform:
         err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND;
     }
     return err;
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     PosixConfig::Key configKey{ PosixConfig::kConfigNamespace_ChipCounters, key };
     return WriteConfigValue(configKey, value);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, bool & val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::ReadConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint16_t & val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::ReadConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint32_t & val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::ReadConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint64_t & val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::ReadConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::ReadConfigValueStr(key, buf, bufSize, outLen);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::ReadConfigValueBin(key, buf, bufSize, outLen);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, bool val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint16_t val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint32_t val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint64_t val)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValue(key, val);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValueStr(key, str);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str, size_t strLen)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValueStr(key, str, strLen);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     return PosixConfig::WriteConfigValueBin(key, data, dataLen);
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 void ConfigurationManagerImpl::RunConfigUnitTest(void)
 {
+#if CHIP_DISABLE_PLATFORM_KVS
+    return;
+#else  // CHIP_DISABLE_PLATFORM_KVS
     PosixConfig::RunConfigUnitTest();
+#endif // CHIP_DISABLE_PLATFORM_KVS
 }
 
 } // namespace DeviceLayer
diff --git a/src/platform/Darwin/PlatformManagerImpl.cpp b/src/platform/Darwin/PlatformManagerImpl.cpp
diff --git a/src/platform/Darwin/PosixConfig.cpp b/src/platform/Darwin/PosixConfig.cpp
diff --git a/src/platform/Darwin/PosixConfig.h b/src/platform/Darwin/PosixConfig.h
diff --git a/src/platform/device.gni b/src/platform/device.gni

Original file line number	Diff line number	Diff line change
`@@ -22,4 +22,6 @@ check_system_includes = true`
`22`	`22`
`23`	`23`	`default_args = {`
`24`	`24`	`import("//args.gni")`
	`25`	`+`
	`26`	`+ chip_disable_platform_kvs = true`
`25`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,6 +108,7 @@ if (chip_device_platform != "none" && chip_device_platform != "external") {`
`108`	`108`	`"CHIP_STACK_LOCK_TRACKING_ERROR_FATAL=${chip_stack_lock_tracking_fatal}",`
`109`	`109`	`"CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING=${chip_enable_additional_data_advertising}",`
`110`	`110`	`"CHIP_DEVICE_CONFIG_RUN_AS_ROOT=${chip_device_config_run_as_root}",`
	`111`	`+ "CHIP_DISABLE_PLATFORM_KVS=${chip_disable_platform_kvs}",`
`111`	`112`	`]`
`112`	`113`
`113`	`114`	`if (chip_device_platform == "linux" \|\| chip_device_platform == "darwin" \|\|`
Original file line number	Diff line number	Diff line change
`@@ -151,6 +151,9 @@ ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance()`
`151`	`151`
`152`	`152`	`CHIP_ERROR ConfigurationManagerImpl::Init()`
`153`	`153`	`{`
	`154`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`155`	`+ return CHIP_NO_ERROR;`
	`156`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`154`	`157`	`// Initialize the generic implementation base class.`
`155`	`158`	`ReturnErrorOnFailure(Internal::GenericConfigurationManagerImpl<PosixConfig>::Init());`
`156`	`159`
`@@ -199,6 +202,7 @@ CHIP_ERROR ConfigurationManagerImpl::Init()`
`199`	`202`	`}`
`200`	`203`
`201`	`204`	`return CHIP_NO_ERROR;`
	`205`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`202`	`206`	`}`
`203`	`207`
`204`	`208`	`CHIP_ERROR ConfigurationManagerImpl::GetPrimaryWiFiMACAddress(uint8_t * buf)`
`@@ -232,56 +236,99 @@ void ConfigurationManagerImpl::InitiateFactoryReset()`
`232`	`236`
`233`	`237`	`CHIP_ERROR ConfigurationManagerImpl::GetVendorId(uint16_t & vendorId)`
`234`	`238`	`{`
	`239`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`240`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`241`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`235`	`242`	`return ReadConfigValue(PosixConfig::kConfigKey_VendorId, vendorId);`
	`243`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`236`	`244`	`}`
`237`	`245`
`238`	`246`	`CHIP_ERROR ConfigurationManagerImpl::GetProductId(uint16_t & productId)`
`239`	`247`	`{`
	`248`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`249`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`250`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`240`	`251`	`return ReadConfigValue(PosixConfig::kConfigKey_ProductId, productId);`
	`252`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`241`	`253`	`}`
`242`	`254`
`243`	`255`	`CHIP_ERROR ConfigurationManagerImpl::StoreVendorId(uint16_t vendorId)`
`244`	`256`	`{`
	`257`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`258`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`259`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`245`	`260`	`return WriteConfigValue(PosixConfig::kConfigKey_VendorId, vendorId);`
	`261`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`246`	`262`	`}`
`247`	`263`
`248`	`264`	`CHIP_ERROR ConfigurationManagerImpl::StoreProductId(uint16_t productId)`
`249`	`265`	`{`
	`266`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`267`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`268`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`250`	`269`	`return WriteConfigValue(PosixConfig::kConfigKey_ProductId, productId);`
	`270`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`251`	`271`	`}`
`252`	`272`
`253`	`273`	`CHIP_ERROR ConfigurationManagerImpl::GetRebootCount(uint32_t & rebootCount)`
`254`	`274`	`{`
	`275`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`276`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`277`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`255`	`278`	`return ReadConfigValue(PosixConfig::kCounterKey_RebootCount, rebootCount);`
	`279`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`256`	`280`	`}`
`257`	`281`
`258`	`282`	`CHIP_ERROR ConfigurationManagerImpl::StoreRebootCount(uint32_t rebootCount)`
`259`	`283`	`{`
	`284`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`285`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`286`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`260`	`287`	`return WriteConfigValue(PosixConfig::kCounterKey_RebootCount, rebootCount);`
	`288`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`261`	`289`	`}`
`262`	`290`
`263`	`291`	`CHIP_ERROR ConfigurationManagerImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours)`
`264`	`292`	`{`
	`293`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`294`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`295`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`265`	`296`	`return ReadConfigValue(PosixConfig::kCounterKey_TotalOperationalHours, totalOperationalHours);`
	`297`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`266`	`298`	`}`
`267`	`299`
`268`	`300`	`CHIP_ERROR ConfigurationManagerImpl::StoreTotalOperationalHours(uint32_t totalOperationalHours)`
`269`	`301`	`{`
	`302`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`303`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`304`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`270`	`305`	`return WriteConfigValue(PosixConfig::kCounterKey_TotalOperationalHours, totalOperationalHours);`
	`306`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`271`	`307`	`}`
`272`	`308`
`273`	`309`	`CHIP_ERROR ConfigurationManagerImpl::GetBootReason(uint32_t & bootReason)`
`274`	`310`	`{`
	`311`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`312`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`313`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`275`	`314`	`return ReadConfigValue(PosixConfig::kCounterKey_BootReason, bootReason);`
	`315`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`276`	`316`	`}`
`277`	`317`
`278`	`318`	`CHIP_ERROR ConfigurationManagerImpl::StoreBootReason(uint32_t bootReason)`
`279`	`319`	`{`
	`320`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`321`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`322`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`280`	`323`	`return WriteConfigValue(PosixConfig::kCounterKey_BootReason, bootReason);`
	`324`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`281`	`325`	`}`
`282`	`326`
`283`	`327`	`CHIP_ERROR ConfigurationManagerImpl::GetRegulatoryLocation(uint8_t & location)`
`284`	`328`	`{`
	`329`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`330`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`331`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`285`	`332`	`uint32_t value = 0;`
`286`	`333`
`287`	`334`	`CHIP_ERROR err = ReadConfigValue(PosixConfig::kConfigKey_RegulatoryLocation, value);`
`@@ -293,10 +340,14 @@ CHIP_ERROR ConfigurationManagerImpl::GetRegulatoryLocation(uint8_t & location)`
`293`	`340`	`}`
`294`	`341`
`295`	`342`	`return err;`
	`343`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`296`	`344`	`}`
`297`	`345`
`298`	`346`	`CHIP_ERROR ConfigurationManagerImpl::GetLocationCapability(uint8_t & location)`
`299`	`347`	`{`
	`348`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`349`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`350`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`300`	`351`	`uint32_t value = 0;`
`301`	`352`
`302`	`353`	`CHIP_ERROR err = ReadConfigValue(PosixConfig::kConfigKey_LocationCapability, value);`
`@@ -308,10 +359,14 @@ CHIP_ERROR ConfigurationManagerImpl::GetLocationCapability(uint8_t & location)`
`308`	`359`	`}`
`309`	`360`
`310`	`361`	`return err;`
	`362`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`311`	`363`	`}`
`312`	`364`
`313`	`365`	`CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value)`
`314`	`366`	`{`
	`367`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`368`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`369`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`315`	`370`	`PosixConfig::Key configKey{ PosixConfig::kConfigNamespace_ChipCounters, key };`
`316`	`371`
`317`	`372`	`CHIP_ERROR err = ReadConfigValue(configKey, value);`
`@@ -320,82 +375,143 @@ CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform:`
`320`	`375`	`err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND;`
`321`	`376`	`}`
`322`	`377`	`return err;`
	`378`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`323`	`379`	`}`
`324`	`380`
`325`	`381`	`CHIP_ERROR ConfigurationManagerImpl::WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value)`
`326`	`382`	`{`
	`383`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`384`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`385`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`327`	`386`	`PosixConfig::Key configKey{ PosixConfig::kConfigNamespace_ChipCounters, key };`
`328`	`387`	`return WriteConfigValue(configKey, value);`
	`388`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`329`	`389`	`}`
`330`	`390`
`331`	`391`	`CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, bool & val)`
`332`	`392`	`{`
	`393`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`394`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`395`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`333`	`396`	`return PosixConfig::ReadConfigValue(key, val);`
	`397`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`334`	`398`	`}`
`335`	`399`
`336`	`400`	`CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint16_t & val)`
`337`	`401`	`{`
	`402`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`403`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`404`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`338`	`405`	`return PosixConfig::ReadConfigValue(key, val);`
	`406`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`339`	`407`	`}`
`340`	`408`
`341`	`409`	`CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint32_t & val)`
`342`	`410`	`{`
	`411`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`412`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`413`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`343`	`414`	`return PosixConfig::ReadConfigValue(key, val);`
	`415`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`344`	`416`	`}`
`345`	`417`
`346`	`418`	`CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint64_t & val)`
`347`	`419`	`{`
	`420`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`421`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`422`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`348`	`423`	`return PosixConfig::ReadConfigValue(key, val);`
	`424`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`349`	`425`	`}`
`350`	`426`
`351`	`427`	`CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen)`
`352`	`428`	`{`
	`429`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`430`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`431`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`353`	`432`	`return PosixConfig::ReadConfigValueStr(key, buf, bufSize, outLen);`
	`433`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`354`	`434`	`}`
`355`	`435`
`356`	`436`	`CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen)`
`357`	`437`	`{`
	`438`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`439`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`440`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`358`	`441`	`return PosixConfig::ReadConfigValueBin(key, buf, bufSize, outLen);`
	`442`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`359`	`443`	`}`
`360`	`444`
`361`	`445`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, bool val)`
`362`	`446`	`{`
	`447`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`448`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`449`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`363`	`450`	`return PosixConfig::WriteConfigValue(key, val);`
	`451`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`364`	`452`	`}`
`365`	`453`
`366`	`454`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint16_t val)`
`367`	`455`	`{`
	`456`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`457`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`458`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`368`	`459`	`return PosixConfig::WriteConfigValue(key, val);`
	`460`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`369`	`461`	`}`
`370`	`462`
`371`	`463`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint32_t val)`
`372`	`464`	`{`
	`465`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`466`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`467`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`373`	`468`	`return PosixConfig::WriteConfigValue(key, val);`
	`469`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`374`	`470`	`}`
`375`	`471`
`376`	`472`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint64_t val)`
`377`	`473`	`{`
	`474`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`475`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`476`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`378`	`477`	`return PosixConfig::WriteConfigValue(key, val);`
	`478`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`379`	`479`	`}`
`380`	`480`
`381`	`481`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str)`
`382`	`482`	`{`
	`483`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`484`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`485`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`383`	`486`	`return PosixConfig::WriteConfigValueStr(key, str);`
	`487`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`384`	`488`	`}`
`385`	`489`
`386`	`490`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str, size_t strLen)`
`387`	`491`	`{`
	`492`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`493`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`494`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`388`	`495`	`return PosixConfig::WriteConfigValueStr(key, str, strLen);`
	`496`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`389`	`497`	`}`
`390`	`498`
`391`	`499`	`CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen)`
`392`	`500`	`{`
	`501`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`502`	`+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;`
	`503`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`393`	`504`	`return PosixConfig::WriteConfigValueBin(key, data, dataLen);`
	`505`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`394`	`506`	`}`
`395`	`507`
`396`	`508`	`void ConfigurationManagerImpl::RunConfigUnitTest(void)`
`397`	`509`	`{`
	`510`	`+#if CHIP_DISABLE_PLATFORM_KVS`
	`511`	`+ return;`
	`512`	`+#else // CHIP_DISABLE_PLATFORM_KVS`
`398`	`513`	`PosixConfig::RunConfigUnitTest();`
	`514`	`+#endif // CHIP_DISABLE_PLATFORM_KVS`
`399`	`515`	`}`
`400`	`516`
`401`	`517`	`} // namespace DeviceLayer`