project-chip · mergify · Aug 15, 2025 · Aug 12, 2025 · Aug 12, 2025 · Aug 12, 2025
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
@@ -339,7 +339,7 @@ jobs:
                   type-safe getters
               if: always()
               run: |
-                  git grep -I -n 'emberAfReadAttribute' -- './*' ':(exclude).github/workflows/lint.yml' ':(exclude)src/app/util/attribute-table.h' ':(exclude)zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' ':(exclude)src/app/zap-templates/templates/app/attributes/Accessors.cpp.zapt' ':(exclude)src/app/util/attribute-table.cpp' ':(exclude)src/app/dynamic_server/DynamicDispatcher.cpp' && exit 1 || exit 0
+                  git grep -I -n 'emberAfReadAttribute' -- './*' ':(exclude).github/workflows/lint.yml' ':(exclude)src/app/util/attribute-table.h' ':(exclude)zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp' ':(exclude)src/app/zap-templates/templates/app/attributes/Accessors.cpp.zapt' ':(exclude)src/app/util/attribute-table.cpp' ':(exclude)src/app/dynamic_server/DynamicDispatcher.cpp' ':(exclude)src/data-model-providers/codegen/ClusterIntegration.cpp' && exit 1 || exit 0
 
             # git grep exits with 0 if it finds a match, but we want
             # to fail (exit nonzero) on match.  And we want to exclude this file,

diff --git a/src/app/clusters/administrator-commissioning-server/CodegenIntegration.cpp b/src/app/clusters/administrator-commissioning-server/CodegenIntegration.cpp
@@ -16,10 +16,9 @@
  */
 #include <app/clusters/administrator-commissioning-server/AdministratorCommissioningCluster.h>
 #include <app/static-cluster-config/AdministratorCommissioning.h>
-#include <data-model-providers/codegen/CodegenDataModelProvider.h>
+#include <data-model-providers/codegen/ClusterIntegration.h>
 
-#include <app-common/zap-generated/attributes/Accessors.h>
-#include <app/util/attribute-storage.h>
+#include <app/util/config.h> // REQUIRED for ifdefs for commands
 
 using namespace chip;
 using namespace chip::app;
@@ -51,43 +50,52 @@ using ClusterImpl = AdministratorCommissioningCluster;
 
 LazyRegisteredServerCluster<ClusterImpl> gServer;
 
-} // namespace
-
-void emberAfAdministratorCommissioningClusterServerInitCallback(EndpointId endpointId)
+class IntegrationDelegate : public CodegenClusterIntegration::Delegate
 {
-    if (endpointId != kRootEndpointId)
+public:
+    ServerClusterRegistration & CreateRegistration(EndpointId endpointId, unsigned emberEndpointIndex,
+                                                   uint32_t optionalAttributeBits, uint32_t featureMap) override
     {
-        return;
+        gServer.Create(endpointId, BitFlags<AdministratorCommissioning::Feature>(featureMap));
+        return gServer.Registration();
     }
 
-    uint32_t rawFeatureMap;
-    if (FeatureMap::Get(endpointId, &rawFeatureMap) != Status::Success)
-    {
-        ChipLogError(AppServer, "Failed to get feature map for endpoint %u", endpointId);
-        rawFeatureMap = 0;
-    }
+    ServerClusterInterface & FindRegistration(unsigned emberEndpointIndex) override { return gServer.Cluster(); }
+    void ReleaseRegistration(unsigned emberEndpointIndex) override { gServer.Destroy(); }
+};
 
-    gServer.Create(endpointId, BitFlags<AdministratorCommissioning::Feature>(rawFeatureMap));
-    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gServer.Registration());
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(AppServer, "Admin Commissioning register error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
-    }
+} // namespace
+
+void emberAfAdministratorCommissioningClusterServerInitCallback(EndpointId endpointId)
+{
+    IntegrationDelegate integrationDelegate;
+
+    // register a singleton server (root endpoint only)
+    CodegenClusterIntegration::RegisterServer(
+        {
+            .endpointId                      = endpointId,
+            .clusterId                       = AdministratorCommissioning::Id,
+            .fixedClusterServerEndpointCount = 1,
+            .maxEndpointCount                = 1,
+            .fetchFeatureMap                 = true,
+            .fetchOptionalAttributes         = false,
+        },
+        integrationDelegate);
 }
 
 void MatterAdministratorCommissioningClusterServerShutdownCallback(EndpointId endpointId)
 {
-    if (endpointId != kRootEndpointId)
-    {
-        return;
-    }
+    IntegrationDelegate integrationDelegate;
 
-    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&gServer.Cluster());
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(AppServer, "Admin Commissioning unregister error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
-    }
-    gServer.Destroy();
+    // register a singleton server (root endpoint only)
+    CodegenClusterIntegration::UnregisterServer(
+        {
+            .endpointId                      = endpointId,
+            .clusterId                       = AdministratorCommissioning::Id,
+            .fixedClusterServerEndpointCount = 1,
+            .maxEndpointCount                = 1,
+        },
+        integrationDelegate);
 }
 
 void MatterAdministratorCommissioningPluginServerInitCallback() {}

diff --git a/src/app/clusters/basic-information/CodegenIntegration.cpp b/src/app/clusters/basic-information/CodegenIntegration.cpp
@@ -19,8 +19,7 @@
 #include <app/static-cluster-config/BasicInformation.h>
 #include <app/util/attribute-storage.h>
 #include <app/util/endpoint-config-api.h>
-#include <data-model-providers/codegen/CodegenDataModelProvider.h>
-#include <lib/support/BitFlags.h>
+#include <data-model-providers/codegen/ClusterIntegration.h>
 
 using namespace chip;
 using namespace chip::app;
@@ -46,44 +45,60 @@ static_assert((kBasicInformationFixedClusterCount == 0) ||
 
 ServerClusterRegistration gRegistration(BasicInformationCluster::Instance());
 
+class IntegrationDelegate : public CodegenClusterIntegration::Delegate
+{
+public:
+    ServerClusterRegistration & CreateRegistration(EndpointId endpointId, unsigned emberEndpointIndex,
+                                                   uint32_t optionalAttributeBits, uint32_t featureMap) override
+    {
+
+        BasicInformationCluster::Instance().OptionalAttributes() =
+            BasicInformationCluster::OptionalAttributesSet(optionalAttributeBits);
+
+        return gRegistration;
+    }
+
+    ServerClusterInterface & FindRegistration(unsigned emberEndpointIndex) override { return BasicInformationCluster::Instance(); }
+
+    // Nothing to destroy: separate singleton class without constructor/destructor is used
+    void ReleaseRegistration(unsigned emberEndpointIndex) override {}
+};
+
 } // namespace
 
 void emberAfBasicInformationClusterServerInitCallback(EndpointId endpointId)
 {
     VerifyOrReturn(endpointId == kRootEndpointId);
 
-    BasicInformationCluster::OptionalAttributesSet & attrs = BasicInformationCluster::Instance().OptionalAttributes();
+    IntegrationDelegate integrationDelegate;
 
-    attrs.Set<ManufacturingDate::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, ManufacturingDate::Id))
-        .Set<PartNumber::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, PartNumber::Id))
-        .Set<ProductURL::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, ProductURL::Id))
-        .Set<ProductLabel::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, ProductLabel::Id))
-        .Set<SerialNumber::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, SerialNumber::Id))
-        .Set<LocalConfigDisabled::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, LocalConfigDisabled::Id))
-        .Set<Reachable::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, Reachable::Id))
-        .Set<ProductAppearance::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, ProductAppearance::Id))
-
-        // This is NOT typical, however we try to respect ZAP here. MCORE_FS tests require this:
-        // Specifically builds need to support the "do not build with unique id (make it optional)"
-        // to emulate the test case where UniqueID is missing as it was optional in previous versions of the spec
-        .Set<UniqueID::Id>(emberAfContainsAttribute(endpointId, BasicInformation::Id, UniqueID::Id));
-
-    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gRegistration);
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(AppServer, "Basic Information register error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
-    }
+    // register a singleton server (root endpoint only)
+    CodegenClusterIntegration::RegisterServer(
+        {
+            .endpointId                      = endpointId,
+            .clusterId                       = BasicInformation::Id,
+            .fixedClusterServerEndpointCount = 1,
+            .maxEndpointCount                = 1,
+            .fetchFeatureMap                 = false,
+            .fetchOptionalAttributes         = true,
+        },
+        integrationDelegate);
 }
 
 void MatterBasicInformationClusterServerShutdownCallback(EndpointId endpointId)
 {
     VerifyOrReturn(endpointId == kRootEndpointId);
 
-    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&BasicInformationCluster::Instance());
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(AppServer, "Basic Information unregister error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
-    }
+    IntegrationDelegate integrationDelegate;
+
+    CodegenClusterIntegration::UnregisterServer(
+        {
+            .endpointId                      = endpointId,
+            .clusterId                       = BasicInformation::Id,
+            .fixedClusterServerEndpointCount = 1,
+            .maxEndpointCount                = 1,
+        },
+        integrationDelegate);
 }
 
 void MatterBasicInformationPluginServerInitCallback() {}

diff --git a/src/app/clusters/general-diagnostics-server/CodegenIntegration.cpp b/src/app/clusters/general-diagnostics-server/CodegenIntegration.cpp
@@ -20,7 +20,7 @@
 #include <app/static-cluster-config/GeneralDiagnostics.h>
 #include <app/util/config.h>
 #include <app/util/util.h>
-#include <data-model-providers/codegen/CodegenDataModelProvider.h>
+#include <data-model-providers/codegen/ClusterIntegration.h>
 
 using namespace chip;
 using namespace chip::app;
@@ -43,61 +43,75 @@ LazyRegisteredServerCluster<GeneralDiagnosticsClusterFullConfigurable> gServer;
 LazyRegisteredServerCluster<GeneralDiagnosticsCluster> gServer;
 #endif
 
-} // namespace
-
-void emberAfGeneralDiagnosticsClusterServerInitCallback(EndpointId endpointId)
+class IntegrationDelegate : public CodegenClusterIntegration::Delegate
 {
-    VerifyOrDie(endpointId == kRootEndpointId);
-
-    GeneralDiagnosticsCluster::OptionalAttributeSet optionalAttributeSet =
-        GeneralDiagnosticsCluster::OptionalAttributeSet()
-            .Set<TotalOperationalHours::Id>(emberAfContainsAttribute(endpointId, GeneralDiagnostics::Id, TotalOperationalHours::Id))
-            .Set<BootReason::Id>(emberAfContainsAttribute(endpointId, GeneralDiagnostics::Id, BootReason::Id))
-            .Set<ActiveHardwareFaults::Id>(emberAfContainsAttribute(endpointId, GeneralDiagnostics::Id, ActiveHardwareFaults::Id))
-            .Set<ActiveRadioFaults::Id>(emberAfContainsAttribute(endpointId, GeneralDiagnostics::Id, ActiveRadioFaults::Id))
-            .Set<ActiveNetworkFaults::Id>(emberAfContainsAttribute(endpointId, GeneralDiagnostics::Id, ActiveNetworkFaults::Id));
+public:
+    ServerClusterRegistration & CreateRegistration(EndpointId endpointId, unsigned emberEndpointIndex,
+                                                   uint32_t optionalAttributeBits, uint32_t featureMap) override
+    {
+        GeneralDiagnosticsCluster::OptionalAttributeSet optionalAttributeSet(optionalAttributeBits);
 
 #if defined(ZCL_USING_TIME_SYNCHRONIZATION_CLUSTER_SERVER) || defined(GENERAL_DIAGNOSTICS_ENABLE_PAYLOAD_TEST_REQUEST_CMD)
-    const GeneralDiagnosticsFunctionsConfig functionsConfig
-    {
-        /*
-        Only consider real time if time sync cluster is actually enabled. If it's not
-        enabled, this avoids likelihood of frequently reporting unusable unsynched time.
-        */
+        const GeneralDiagnosticsFunctionsConfig functionsConfig
+        {
+            /*
+            Only consider real time if time sync cluster is actually enabled. If it's not
+            enabled, this avoids likelihood of frequently reporting unusable unsynched time.
+            */
 #if defined(ZCL_USING_TIME_SYNCHRONIZATION_CLUSTER_SERVER)
-        .enablePosixTime = true,
+            .enablePosixTime = true,
 #else
-        .enablePosixTime      = false,
+            .enablePosixTime      = false,
 #endif
 #if defined(GENERAL_DIAGNOSTICS_ENABLE_PAYLOAD_TEST_REQUEST_CMD)
-        .enablePayloadSnaphot = true,
+            .enablePayloadSnaphot = true,
 #else
-        .enablePayloadSnaphot = false,
+            .enablePayloadSnaphot = false,
 #endif
-    };
-    gServer.Create(optionalAttributeSet, functionsConfig);
+        };
+        gServer.Create(optionalAttributeSet, functionsConfig);
 #else
-    gServer.Create(optionalAttributeSet);
+        gServer.Create(optionalAttributeSet);
 #endif
-
-    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gServer.Registration());
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(AppServer, "Failed to register GeneralDiagnostics on endpoint %u: %" CHIP_ERROR_FORMAT, endpointId,
-                     err.Format());
+        return gServer.Registration();
     }
+
+    ServerClusterInterface & FindRegistration(unsigned emberEndpointIndex) override { return gServer.Cluster(); }
+    void ReleaseRegistration(unsigned emberEndpointIndex) override { gServer.Destroy(); }
+};
+
+} // namespace
+
+void emberAfGeneralDiagnosticsClusterServerInitCallback(EndpointId endpointId)
+{
+    IntegrationDelegate integrationDelegate;
+
+    // register a singleton server (root endpoint only)
+    CodegenClusterIntegration::RegisterServer(
+        {
+            .endpointId                      = endpointId,
+            .clusterId                       = GeneralDiagnostics::Id,
+            .fixedClusterServerEndpointCount = 1,
+            .maxEndpointCount                = 1,
+            .fetchFeatureMap                 = false,
+            .fetchOptionalAttributes         = true,
+        },
+        integrationDelegate);
 }
 
 void MatterGeneralDiagnosticsClusterServerShutdownCallback(EndpointId endpointId)
 {
-    VerifyOrReturn(endpointId == kRootEndpointId);
-    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&gServer.Cluster());
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(AppServer, "Failed to unregister GeneralDiagnostics on endpoint %u: %" CHIP_ERROR_FORMAT, endpointId,
-                     err.Format());
-    }
-    gServer.Destroy();
+    IntegrationDelegate integrationDelegate;
+
+    // register a singleton server (root endpoint only)
+    CodegenClusterIntegration::UnregisterServer(
+        {
+            .endpointId                      = endpointId,
+            .clusterId                       = GeneralDiagnostics::Id,
+            .fixedClusterServerEndpointCount = 1,
+            .maxEndpointCount                = 1,
+        },
+        integrationDelegate);
 }
 
 void MatterGeneralDiagnosticsPluginServerInitCallback() {}