OpenThread: added Thread interface enabled support

src/platform/OpenThread/GenericNetworkCommissioningThreadDriver.cpp

@@ -95,6 +95,12 @@ CHIP_ERROR GenericThreadDriver::RevertConfiguration()
     // since the fail-safe was armed, so return with no error.
     ReturnErrorCodeIf(error == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND, CHIP_NO_ERROR);
 
+    if (!GetEnabled())
+    {
+        // If backup is found, set InterfaceEnabled to default value (true).
+        ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Delete(kInterfaceEnabled));
+    }
+
     ChipLogProgress(NetworkProvisioning, "Reverting Thread operational dataset");
 
     if (error == CHIP_NO_ERROR)
@@ -166,6 +172,12 @@ void GenericThreadDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * c
 {
     NetworkCommissioning::Status status = MatchesNetworkId(mStagingNetwork, networkId);
 
+    if (!GetEnabled())
+    {
+        // Set InterfaceEnabled to default value (true).
+        ReturnOnFailure(PersistedStorage::KeyValueStoreMgr().Delete(kInterfaceEnabled));
+    }
+
     if (status == Status::kSuccess && BackupConfiguration() != CHIP_NO_ERROR)
     {
         status = Status::kUnknownError;
@@ -183,6 +195,31 @@ void GenericThreadDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * c
     }
 }
 
+CHIP_ERROR GenericThreadDriver::SetEnabled(bool enabled)
+{
+    if (enabled == GetEnabled())
+    {
+        return CHIP_NO_ERROR;
+    }
+
+    ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Put(kInterfaceEnabled, &enabled, sizeof(enabled)));
+
+    if ((!enabled && DeviceLayer::ThreadStackMgrImpl().IsThreadEnabled()) ||
+        (enabled && DeviceLayer::ThreadStackMgrImpl().IsThreadProvisioned()))
+    {
+        ReturnErrorOnFailure(DeviceLayer::ThreadStackMgrImpl().SetThreadEnabled(enabled));
+    }
+    return CHIP_NO_ERROR;
+}
+
+bool GenericThreadDriver::GetEnabled()
+{
+    bool value;
+    // InterfaceEnabled default value is true.
+    VerifyOrReturnValue(PersistedStorage::KeyValueStoreMgr().Get(kInterfaceEnabled, &value, sizeof(value)) == CHIP_NO_ERROR, true);
+    return value;
+}
+
 void GenericThreadDriver::ScanNetworks(ThreadDriver::ScanCallback * callback)
 {
     if (DeviceLayer::ThreadStackMgrImpl().StartThreadScan(callback) != CHIP_NO_ERROR)

src/platform/OpenThread/GenericNetworkCommissioningThreadDriver.h

@@ -90,6 +90,8 @@ class GenericThreadDriver final : public ThreadDriver
     // BaseDriver
     NetworkIterator * GetNetworks() override { return new ThreadNetworkIterator(this); }
     CHIP_ERROR Init(Internal::BaseDriver::NetworkStatusChangeCallback * statusChangeCallback) override;
+    CHIP_ERROR SetEnabled(bool enabled) override;
+    bool GetEnabled() override;
     void Shutdown() override;
 
     // WirelessDriver
@@ -114,6 +116,7 @@ class GenericThreadDriver final : public ThreadDriver
     void ScanNetworks(ThreadDriver::ScanCallback * callback) override;
 
 private:
+    static constexpr const char * kInterfaceEnabled = "g/gtd/en";
     uint8_t scanNetworkTimeoutSeconds;
     uint8_t connectNetworkTimeout;
     static void OnThreadStateChangeHandler(const ChipDeviceEvent * event, intptr_t arg);

src/platform/OpenThread/GenericThreadStackManagerImpl_OpenThread.hpp

@@ -1094,6 +1094,9 @@ CHIP_ERROR GenericThreadStackManagerImpl_OpenThread<ImplClass>::DoInit(otInstanc
     CHIP_ERROR err = CHIP_NO_ERROR;
     otError otErr  = OT_ERROR_NONE;
 
+    // If InterfaceEnabled is false, do not start Thread
+    bool InterfaceEnabled = true;
+
     // Arrange for OpenThread errors to be translated to text.
     RegisterOpenThreadErrorFormatter();
 
@@ -1131,8 +1134,12 @@ CHIP_ERROR GenericThreadStackManagerImpl_OpenThread<ImplClass>::DoInit(otInstanc
     memset(&mSrpClient, 0, sizeof(mSrpClient));
 #endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD_SRP_CLIENT
 
+#ifndef _NO_NETWORK_COMMISSIONING_DRIVER_
+    InterfaceEnabled = sGenericThreadDriver.GetEnabled();
+#endif
+
     // If the Thread stack has been provisioned, but is not currently enabled, enable it now.
-    if (otThreadGetDeviceRole(mOTInst) == OT_DEVICE_ROLE_DISABLED && otDatasetIsCommissioned(otInst))
+    if (InterfaceEnabled && otThreadGetDeviceRole(mOTInst) == OT_DEVICE_ROLE_DISABLED && otDatasetIsCommissioned(otInst))
     {
         // Enable the Thread IPv6 interface.
         otErr = otIp6SetEnabled(otInst, true);