wip

src/app/BUILD.gn

@@ -63,11 +63,7 @@ declare_args() {
 config("enhanced_setup_flow_config") {
   defines = []
   if (chip_config_tc_required) {
-    defines += [
-      "CHIP_CONFIG_TC_REQUIRED=1",
-      "CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS=${chip_config_tc_required_acknowledgements}",
-      "CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION=${chip_config_tc_required_acknowledgements_version}",
-    ]
+    defines += [ "CHIP_CONFIG_TC_REQUIRED=1" ]
   } else {
     defines += [ "CHIP_CONFIG_TC_REQUIRED=0" ]
   }
@@ -93,6 +89,13 @@ buildconfig_header("app_buildconfig") {
     "CHIP_CONFIG_ENABLE_BUSY_HANDLING_FOR_OPERATIONAL_SESSION_SETUP=${chip_enable_busy_handling_for_operational_session_setup}",
   ]
 
+  if (chip_config_tc_required) {
+    defines += [
+      "CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS=${chip_config_tc_required_acknowledgements}",
+      "CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION=${chip_config_tc_required_acknowledgements_version}",
+    ]
+  }
+
   if (chip_use_data_model_interface == "disabled") {
     defines += [
       "CHIP_CONFIG_USE_DATA_MODEL_INTERFACE=0",

src/app/clusters/general-commissioning-server/general-commissioning-server.cpp

@@ -304,8 +304,6 @@ bool emberAfGeneralCommissioningClusterCommissioningCompleteCallback(
         else
         {
 #if CHIP_CONFIG_TC_REQUIRED
-            // CheckSuccess(CheckTermsAndConditionsAcknowledgementsStateOnCommissioningComplete(response.errorCode), Failure);
-
             EnhancedSetupFlowProvider * const enhancedSetupFlowProvider = Server::GetInstance().GetEnhancedSetupFlowProvider();
 
             Optional<TermsAndConditions> acceptedTermsAndConditions;

src/app/server/DefaultEnhancedSetupFlowProvider.cpp

@@ -24,9 +24,7 @@
 CHIP_ERROR chip::app::DefaultEnhancedSetupFlowProvider::Init(TermsAndConditionsProvider * const inTermsAndConditionsProvider)
 {
     VerifyOrReturnError(nullptr != inTermsAndConditionsProvider, CHIP_ERROR_INVALID_ARGUMENT);
-
     mTermsAndConditionsProvider = inTermsAndConditionsProvider;
-
     return CHIP_NO_ERROR;
 }
 
@@ -55,18 +53,23 @@ CHIP_ERROR chip::app::DefaultEnhancedSetupFlowProvider::SetTermsAndConditionsAcc
     return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR chip::app::DefaultEnhancedSetupFlowProvider::ResetTermsAndConditionsAcceptance()
+{
+    VerifyOrReturnError(nullptr != mTermsAndConditionsProvider, CHIP_ERROR_UNINITIALIZED);
+    ReturnErrorOnFailure(mTermsAndConditionsProvider->ResetAcceptance());
+    return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR chip::app::DefaultEnhancedSetupFlowProvider::RevertTermsAndConditionsAcceptance()
 {
     VerifyOrReturnError(nullptr != mTermsAndConditionsProvider, CHIP_ERROR_UNINITIALIZED);
     ReturnErrorOnFailure(mTermsAndConditionsProvider->RevertAcceptance());
-
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR chip::app::DefaultEnhancedSetupFlowProvider::CommitTermsAndConditionsAcceptance()
 {
     VerifyOrReturnError(nullptr != mTermsAndConditionsProvider, CHIP_ERROR_UNINITIALIZED);
     ReturnErrorOnFailure(mTermsAndConditionsProvider->CommitAcceptance());
-
     return CHIP_NO_ERROR;
 }

src/app/server/DefaultEnhancedSetupFlowProvider.h

@@ -45,6 +45,8 @@ class DefaultEnhancedSetupFlowProvider : public EnhancedSetupFlowProvider
 
     virtual CHIP_ERROR SetTermsAndConditionsAcceptance(const Optional<TermsAndConditions> & inTermsAndConditions) override;
 
+    virtual CHIP_ERROR ResetTermsAndConditionsAcceptance() override;
+
     virtual CHIP_ERROR RevertTermsAndConditionsAcceptance() override;
 
     virtual CHIP_ERROR CommitTermsAndConditionsAcceptance() override;

src/app/server/DefaultTermsAndConditionsProvider.cpp

@@ -26,6 +26,37 @@
 #include <lib/support/DefaultStorageKeyAllocator.h>
 #include <lib/support/SafeInt.h>
 
+#if 0
+/**
+ * @def CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS
+ *
+ * @brief Configures the required terms and conditions acknowledgements bitmask.
+ *
+ * This macro defines the required terms and conditions acknowledgements bitmask. The bit-field is 16 bits long, so the possible
+ * value range is [0, 65535). This setting can be used to require that terms and conditions are presented to the user during
+ * commissioning.
+ */
+#ifndef CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS
+#error "CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS must be defined when CHIP_CONFIG_TC_REQUIRED is enabled."
+#endif
+
+/**
+ * @def CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION
+ *
+ * @brief Configures the latest known version of the terms and conditions.
+ *
+ * This macro defines the version number of the latest terms and conditions. It allows the application to iterate on revisions of
+ * the terms and conditions. A value of 0 indicates that no specific version is required. This setting can be used to enforce
+ * version-specific terms and conditions acknowledgements in the application. When the set of terms and conditions needs to be
+ * changed, the version number should be monotonically increased. If the latest terms and conditions version is updated (most
+ * likely during an OTA), then this may signal to the Administrator that updated terms and conditions should be presented to the
+ * user.
+ */
+#ifndef CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION
+#error "CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION must be defined when CHIP_CONFIG_TC_REQUIRED is enabled."
+#endif
+#endif // 0
+
 namespace {
 constexpr chip::TLV::Tag kSerializationVersionTag            = chip::TLV::ContextTag(1);
 constexpr chip::TLV::Tag kAcceptedAcknowledgementsTag        = chip::TLV::ContextTag(2);
@@ -39,16 +70,14 @@ constexpr size_t kEstimatedTlvBufferSize = chip::TLV::EstimateStructOverhead(siz
     2; // Extra space for rollback compatibility
 } // namespace
 
-CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::Init(chip::PersistentStorageDelegate * const inPersistentStorageDelegate)
+CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::Init(
+    chip::PersistentStorageDelegate * const inPersistentStorageDelegate,
+    const chip::Optional<chip::app::TermsAndConditions> & inRequiredTermsAndConditions)
 {
     VerifyOrReturnError(nullptr != inPersistentStorageDelegate, CHIP_ERROR_INVALID_ARGUMENT);
 
     mPersistentStorageDelegate = inPersistentStorageDelegate;
-
-    mRequiredAcknowledgements = Optional<TermsAndConditions>({
-        .value   = CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS,
-        .version = CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION,
-    });
+    mRequiredAcknowledgements  = inRequiredTermsAndConditions;
 
     if (CHIP_NO_ERROR == LoadAcceptance(mLatchedAcceptance))
     {
@@ -60,7 +89,7 @@ CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::Init(chip::PersistentSt
 
 CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::RevertAcceptance()
 {
-    mTemporalAcceptance.SetValue(mLatchedAcceptance.Value());
+    mTemporalAcceptance = mLatchedAcceptance;
     return CHIP_NO_ERROR;
 }
 
@@ -77,23 +106,13 @@ CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::CommitAcceptance()
 
 CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::GetAcceptance(Optional<TermsAndConditions> & outTermsAndConditions) const
 {
-    if (!mTemporalAcceptance.HasValue())
-    {
-        return CHIP_ERROR_INCORRECT_STATE;
-    }
-
-    outTermsAndConditions.SetValue(mTemporalAcceptance.Value());
+    outTermsAndConditions = mTemporalAcceptance;
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR chip::app::DefaultTermsAndConditionsProvider::GetRequirements(Optional<TermsAndConditions> & outTermsAndConditions) const
 {
-    if (!mRequiredAcknowledgements.HasValue())
-    {
-        return CHIP_ERROR_INCORRECT_STATE;
-    }
-
-    outTermsAndConditions.SetValue(mRequiredAcknowledgements.Value());
+    outTermsAndConditions = mRequiredAcknowledgements;
     return CHIP_NO_ERROR;
 }
 

src/app/server/DefaultTermsAndConditionsProvider.h

@@ -36,7 +36,8 @@ class DefaultTermsAndConditionsProvider : public TermsAndConditionsProvider
      *
      * @param[in] inPersistentStorageDelegate Persistent storage delegate dependency.
      */
-    CHIP_ERROR Init(PersistentStorageDelegate * const inPersistentStorageDelegate);
+    CHIP_ERROR Init(PersistentStorageDelegate * const inPersistentStorageDelegate,
+                    const chip::Optional<chip::app::TermsAndConditions> & inRequiredTermsAndConditions);
 
     CHIP_ERROR SetAcceptance(const Optional<TermsAndConditions> & inTermsAndConditions) override;
 

src/app/server/EnhancedSetupFlowProvider.h

@@ -41,6 +41,8 @@ class EnhancedSetupFlowProvider
 
     virtual CHIP_ERROR SetTermsAndConditionsAcceptance(const Optional<TermsAndConditions> & inTermsAndConditions) = 0;
 
+    virtual CHIP_ERROR ResetTermsAndConditionsAcceptance() = 0;
+
     virtual CHIP_ERROR RevertTermsAndConditionsAcceptance() = 0;
 
     virtual CHIP_ERROR CommitTermsAndConditionsAcceptance() = 0;

src/app/server/Server.cpp

@@ -599,8 +599,7 @@ void Server::ScheduleFactoryReset()
         PlatformMgr().HandleServerShuttingDown();
         ConfigurationMgr().InitiateFactoryReset();
 #if CHIP_CONFIG_TC_REQUIRED
-        // Clear accepted terms and conditions
-        GetInstance().GetEnhancedSetupFlowProvider()->RevertTermsAndConditionsAcceptance();
+        GetInstance().GetEnhancedSetupFlowProvider()->ResetTermsAndConditionsAcceptance();
 #endif
     });
 }

src/app/server/Server.h

@@ -322,9 +322,16 @@ struct CommonCaseDeviceServerInitParams : public ServerInitParams
 #if CHIP_CONFIG_TC_REQUIRED
         static app::DefaultEnhancedSetupFlowProvider sDefaultEnhancedSetupFlowProviderInstance;
         static app::DefaultTermsAndConditionsProvider sDefaultTermsAndConditionsProviderInstance;
+
         if (this->termsAndConditionsProvider == nullptr)
         {
-            ReturnErrorOnFailure(sDefaultTermsAndConditionsProviderInstance.Init(this->persistentStorageDelegate));
+            Optional<app::TermsAndConditions> termsAndConditions = Optional<app::TermsAndConditions>({
+                .value   = CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS,
+                .version = CHIP_CONFIG_TC_REQUIRED_ACKNOWLEDGEMENTS_VERSION,
+            });
+
+            ReturnErrorOnFailure(
+                sDefaultTermsAndConditionsProviderInstance.Init(this->persistentStorageDelegate, termsAndConditions));
             this->termsAndConditionsProvider = &sDefaultTermsAndConditionsProviderInstance;
         }
 

src/app/server/TermsAndConditionsProvider.h

@@ -20,7 +20,6 @@
 
 #include <stdint.h>
 
-#include <lib/core/CHIPConfig.h>
 #include <lib/core/CHIPError.h>
 #include <lib/core/Optional.h>
 

src/app/tests/BUILD.gn

@@ -199,7 +199,6 @@ chip_test_suite("tests") {
     "TestCommandPathParams.cpp",
     "TestConcreteAttributePath.cpp",
     "TestDataModelSerialization.cpp",
-    "TestDefaultEnhancedSetupFlowProvider.cpp",
     "TestDefaultOTARequestorStorage.cpp",
     "TestDefaultTermsAndConditionsProvider.cpp",
     "TestDefaultThreadNetworkDirectoryStorage.cpp",