Skip to content

Commit 2b53d0f

Browse files
andy31415andy31415
committed
Add a context go generalcommissioning cluster, so that everything is
dependency injected.
1 parent 1992150 commit 2b53d0f

15 files changed

+1388
-1458
lines changed

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

Lines changed: 36 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -17,11 +17,23 @@
1717
*/
1818
#include <app/clusters/general-commissioning-server/CodegenIntegration.h>
1919

20+
#include <platform/ConfigurationManager.h>
21+
#include <platform/DeviceControlServer.h>
22+
#include <platform/PlatformManager.h>
2023
#include <app/clusters/general-commissioning-server/general-commissioning-cluster.h>
2124
#include <app/server-cluster/ServerClusterInterfaceRegistry.h>
25+
#include <app/server/Server.h>
2226
#include <app/static-cluster-config/GeneralCommissioning.h>
2327
#include <data-model-providers/codegen/ClusterIntegration.h>
2428
#include <lib/support/CodeUtils.h>
29+
#include <platform/ConfigurationManager.h>
30+
#include <platform/DeviceControlServer.h>
31+
#include <platform/PlatformManager.h>
32+
#include <lib/core/DataModelTypes.h>
33+
#include <lib/support/CodeUtils.h>
34+
#include <platform/ConfigurationManager.h>
35+
#include <platform/DeviceControlServer.h>
36+
#include <platform/PlatformManager.h>
2537

2638
using namespace chip;
2739
using namespace chip::app;
@@ -46,21 +58,38 @@ static_assert((kGeneralCommissioningFixedClusterCount == 0) ||
4658
GeneralCommissioning::StaticApplicationConfig::kFixedClusterConfig[0].endpointNumber == kRootEndpointId),
4759
"General Commissioning cluster MUST be on endpoint 0");
4860

49-
RegisteredServerCluster<GeneralCommissioningCluster> gRegistration;
61+
LazyRegisteredServerCluster<GeneralCommissioningCluster> gServer;
5062

5163
class IntegrationDelegate : public CodegenClusterIntegration::Delegate
5264
{
5365
public:
5466
ServerClusterRegistration & CreateRegistration(EndpointId endpointId, unsigned clusterInstanceIndex,
5567
uint32_t optionalAttributeBits, uint32_t featureMap) override
5668
{
69+
70+
gServer.Create(GeneralCommissioningCluster::Context {
71+
.commissioningWindowManager = Server::GetInstance().GetCommissioningWindowManager(), //
72+
.configurationManager = DeviceLayer::ConfigurationMgr(), //
73+
.deviceControlServer = DeviceLayer::DeviceControlServer::DeviceControlSvr(), //
74+
.fabricTable = Server::GetInstance().GetFabricTable(), //
75+
.failsafeContext = Server::GetInstance().GetFailSafeContext(), //
76+
.platformManager = DeviceLayer::PlatformMgr(), //
77+
#if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
78+
.termsAndConditionsProvider = TermsAndConditionsManager::GetInstance(),
79+
#endif // CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
80+
});
81+
5782
// Configure optional attributes based on fetched bits
58-
gRegistration.Cluster().GetOptionalAttributes() = GeneralCommissioningCluster::OptionalAttributes(optionalAttributeBits);
83+
gServer.Cluster().GetOptionalAttributes() = GeneralCommissioningCluster::OptionalAttributes(optionalAttributeBits);
5984

60-
return gRegistration.Registration();
85+
return gServer.Registration();
6186
}
6287

63-
ServerClusterInterface * FindRegistration(unsigned clusterInstanceIndex) override { return &gRegistration.Cluster(); }
88+
ServerClusterInterface * FindRegistration(unsigned clusterInstanceIndex) override
89+
{
90+
VerifyOrReturnValue(gServer.IsConstructed(), nullptr);
91+
return &gServer.Cluster();
92+
}
6493

6594
// Nothing to destroy: gRegistration is a global static that handles destruction
6695
void ReleaseRegistration(unsigned clusterInstanceIndex) override {}
@@ -72,24 +101,22 @@ namespace chip::app::Clusters::GeneralCommissioning {
72101

73102
GeneralCommissioningCluster * Instance()
74103
{
75-
// we ALWAYS return this for now, however in the future this may be instantiated
76-
// at runtime (i.e only after server is initialized.)
77-
return &gRegistration.Cluster();
104+
VerifyOrReturnValue(gServer.IsConstructed(), nullptr);
105+
return &gServer.Cluster();
78106
}
79107

80108
} // namespace chip::app::Clusters::GeneralCommissioning
81109

82110
void MatterGeneralCommissioningClusterInitCallback(EndpointId endpointId)
83111
{
84112
VerifyOrReturn(endpointId == kRootEndpointId);
85-
86113
IntegrationDelegate integrationDelegate;
87114

88115
// register a singleton server (root endpoint only)
89116
// Startup() will be called automatically by the registry when context is set
90117
CodegenClusterIntegration::RegisterServer(
91118
{
92-
.endpointId = endpointId,
119+
.endpointId = kRootEndpointId,
93120
.clusterId = GeneralCommissioning::Id,
94121
.fixedClusterInstanceCount = GeneralCommissioning::StaticApplicationConfig::kFixedClusterConfig.size(),
95122
.maxClusterInstanceCount = 1, // Cluster is a singleton on the root node and this is the only thing supported

‎src/app/clusters/general-commissioning-server/app_config_dependent_sources.cmake‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ TARGET_SOURCES(
1818
${APP_TARGET}
1919
PRIVATE
2020
"${CLUSTER_DIR}/CodegenIntegration.cpp"
21+
"${CLUSTER_DIR}/CodegenIntegration.h"
2122
)
2223

2324
# These are the things that BUILD.gn dependencies would pull

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

Lines changed: 35 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
*/
1717

1818
#include "general-commissioning-cluster.h"
19+
#include "platform/ConfigurationManager.h"
1920

2021
#include <app/AppConfig.h>
2122
#include <app/reporting/reporting.h>
@@ -32,9 +33,8 @@
3233
#include <transport/SecureSession.h>
3334

3435
#if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
35-
#include <app/server/TermsAndConditionsManager.h> //nogncheck
36-
#include <app/server/TermsAndConditionsProvider.h> //nogncheck
37-
#endif
36+
#include <app/server/TermsAndConditionsManager.h> //nogncheck
37+
#endif // CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
3838

3939
using namespace chip;
4040
using namespace chip::app;
@@ -57,10 +57,11 @@ namespace {
5757
} \
5858
} while (false)
5959

60-
CHIP_ERROR ReadIfSupported(CHIP_ERROR (ConfigurationManager::*getter)(uint8_t &), AttributeValueEncoder & aEncoder)
60+
CHIP_ERROR ReadIfSupported(ConfigurationManager & mgr, CHIP_ERROR (ConfigurationManager::*getter)(uint8_t &),
61+
AttributeValueEncoder & aEncoder)
6162
{
6263
uint8_t data = 0;
63-
CHIP_ERROR err = (DeviceLayer::ConfigurationMgr().*getter)(data);
64+
CHIP_ERROR err = (mgr.*getter)(data);
6465
if (err == CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE)
6566
{
6667
data = 0;
@@ -143,14 +144,16 @@ void OnPlatformEventHandler(const DeviceLayer::ChipDeviceEvent * event, intptr_t
143144
{
144145
if (event->Type == DeviceLayer::DeviceEventType::kFailSafeTimerExpired)
145146
{
147+
auto self = reinterpret_cast<GeneralCommissioningCluster *>(arg);
148+
146149
// Spec says to reset Breadcrumb attribute to 0.
147-
reinterpret_cast<GeneralCommissioningCluster *>(self)->SetBreadCrumb(0);
150+
self->SetBreadCrumb(0);
148151

149152
#if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
150153
if (event->FailSafeTimerExpired.updateTermsAndConditionsHasBeenInvoked)
151154
{
152155
// Clear terms and conditions acceptance on failsafe timer expiration
153-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
156+
TermsAndConditionsProvider & tcProvider = self->ClusterContext().termsAndConditionsProvider;
154157
TermsAndConditionsState initialState, updatedState;
155158
VerifyOrReturn(CHIP_NO_ERROR == GetTermsAndConditionsAttributeState(tcProvider, initialState));
156159
VerifyOrReturn(CHIP_NO_ERROR == tcProvider.RevertAcceptance());
@@ -190,56 +193,44 @@ DataModel::ActionReturnStatus GeneralCommissioningCluster::ReadAttribute(const D
190193
return encoder.Encode(info);
191194
}
192195
case RegulatoryConfig::Id:
193-
return ReadIfSupported(&ConfigurationManager::GetRegulatoryLocation, encoder);
196+
return ReadIfSupported(mClusterContext.configurationManager, &ConfigurationManager::GetRegulatoryLocation, encoder);
194197
case LocationCapability::Id:
195-
return ReadIfSupported(&ConfigurationManager::GetLocationCapability, encoder);
198+
return ReadIfSupported(mClusterContext.configurationManager, &ConfigurationManager::GetLocationCapability, encoder);
196199
case SupportsConcurrentConnection::Id:
197200
return encoder.Encode(CHIP_DEVICE_CONFIG_SUPPORTS_CONCURRENT_CONNECTION != 0);
198201

199202
#if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
200203
case TCAcceptedVersion::Id: {
201-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
202204
Optional<TermsAndConditions> outTermsAndConditions;
203-
204-
ReturnErrorOnFailure(tcProvider.GetAcceptance(outTermsAndConditions));
205-
205+
ReturnErrorOnFailure(mClusterContext.termsAndConditionsProvider.GetAcceptance(outTermsAndConditions));
206206
return encoder.Encode(outTermsAndConditions.ValueOr(TermsAndConditions(0, 0)).GetVersion());
207207
}
208208
case TCMinRequiredVersion::Id: {
209-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
210209
Optional<TermsAndConditions> outTermsAndConditions;
211210

212-
ReturnErrorOnFailure(tcProvider.GetRequirements(outTermsAndConditions));
213-
211+
ReturnErrorOnFailure(mClusterContext.termsAndConditionsProvider.GetRequirements(outTermsAndConditions));
214212
return encoder.Encode(outTermsAndConditions.ValueOr(TermsAndConditions(0, 0)).GetVersion());
215213
}
216214
case TCAcknowledgements::Id: {
217-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
218215
Optional<TermsAndConditions> outTermsAndConditions;
219216

220-
ReturnErrorOnFailure(tcProvider.GetAcceptance(outTermsAndConditions));
221-
217+
ReturnErrorOnFailure(mClusterContext.termsAndConditionsProvider.GetAcceptance(outTermsAndConditions));
222218
return encoder.Encode(outTermsAndConditions.ValueOr(TermsAndConditions(0, 0)).GetValue());
223219
}
224220
case TCAcknowledgementsRequired::Id: {
225-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
226221
bool acknowledgementsRequired;
227-
228-
ReturnErrorOnFailure(tcProvider.GetAcknowledgementsRequired(acknowledgementsRequired));
229-
222+
ReturnErrorOnFailure(mClusterContext.termsAndConditionsProvider.GetAcknowledgementsRequired(acknowledgementsRequired));
230223
return encoder.Encode(acknowledgementsRequired);
231224
}
232225
case TCUpdateDeadline::Id: {
233-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
234226
Optional<uint32_t> outUpdateAcceptanceDeadline;
227+
ReturnErrorOnFailure(mClusterContext.termsAndConditionsProvider.GetUpdateAcceptanceDeadline(outUpdateAcceptanceDeadline));
235228

236-
ReturnErrorOnFailure(tcProvider.GetUpdateAcceptanceDeadline(outUpdateAcceptanceDeadline));
237-
229+
// NOTE: encoding an optional as a Nullable (they are not fully compatible)
238230
if (!outUpdateAcceptanceDeadline.HasValue())
239231
{
240232
return encoder.EncodeNull();
241233
}
242-
243234
return encoder.Encode(outUpdateAcceptanceDeadline.Value());
244235
}
245236
#endif
@@ -372,12 +363,12 @@ void GeneralCommissioningCluster::OnFabricRemoved(const FabricTable & fabricTabl
372363
#if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
373364
// If the FabricIndex matches the last remaining entry in the Fabrics list, then the device SHALL delete all Matter
374365
// related data on the node which was created since it was commissioned.
375-
if (Server::GetInstance().GetFabricTable().FabricCount() == 0)
366+
if (fabricTable.FabricCount() == 0)
376367
{
377368
ChipLogProgress(Zcl, "general-commissioning-server: Last Fabric index 0x%x was removed",
378369
static_cast<unsigned>(fabricIndex));
379370

380-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
371+
TermsAndConditionsProvider & tcProvider = mClusterContext.termsAndConditionsProvider;
381372
TermsAndConditionsState initialState, updatedState;
382373
VerifyOrReturn(CHIP_NO_ERROR == GetTermsAndConditionsAttributeState(tcProvider, initialState));
383374
VerifyOrReturn(CHIP_NO_ERROR == tcProvider.ResetAcceptance());
@@ -397,15 +388,15 @@ void GeneralCommissioningCluster::SetBreadCrumb(uint64_t value)
397388
CHIP_ERROR GeneralCommissioningCluster::Startup(ServerClusterContext & context)
398389
{
399390
ReturnErrorOnFailure(DefaultServerCluster::Startup(context));
400-
PlatformMgrImpl().AddEventHandler(OnPlatformEventHandler, reinterpret_cast<intptr_t>(this));
401-
Server::GetInstance().GetFabricTable().AddFabricDelegate(this);
391+
mClusterContext.platformManager.AddEventHandler(OnPlatformEventHandler, reinterpret_cast<intptr_t>(this));
392+
mClusterContext.fabricTable.AddFabricDelegate(this);
402393
return CHIP_NO_ERROR;
403394
}
404395

405396
void GeneralCommissioningCluster::Shutdown()
406397
{
407-
PlatformMgrImpl().RemoveEventHandler(OnPlatformEventHandler, reinterpret_cast<intptr_t>(this));
408-
Server::GetInstance().GetFabricTable().RemoveFabricDelegate(this);
398+
mClusterContext.platformManager.RemoveEventHandler(OnPlatformEventHandler, reinterpret_cast<intptr_t>(this));
399+
mClusterContext.fabricTable.RemoveFabricDelegate(this);
409400
DefaultServerCluster::Shutdown();
410401
}
411402

@@ -414,7 +405,7 @@ GeneralCommissioningCluster::HandleArmFailSafe(const DataModel::InvokeRequest &
414405
const GeneralCommissioning::Commands::ArmFailSafe::DecodableType & commandData)
415406
{
416407
MATTER_TRACE_SCOPE("ArmFailSafe", "GeneralCommissioning");
417-
auto & failSafeContext = Server::GetInstance().GetFailSafeContext();
408+
auto & failSafeContext = mClusterContext.failsafeContext;
418409
Commands::ArmFailSafeResponse::Type response;
419410

420411
ChipLogProgress(FailSafe, "GeneralCommissioning: Received ArmFailSafe (%us)",
@@ -435,8 +426,7 @@ GeneralCommissioningCluster::HandleArmFailSafe(const DataModel::InvokeRequest &
435426
{
436427
// We do not allow CASE connections to arm the failsafe for the first time while the commissioning window is open in order
437428
// to allow commissioners the opportunity to obtain this failsafe for the purpose of commissioning
438-
if (!failSafeContext.IsFailSafeArmed() &&
439-
Server::GetInstance().GetCommissioningWindowManager().IsCommissioningWindowOpen() &&
429+
if (!failSafeContext.IsFailSafeArmed() && mClusterContext.commissioningWindowManager.IsCommissioningWindowOpen() &&
440430
request.subjectDescriptor->authMode == Access::AuthMode::kCase)
441431
{
442432
response.errorCode = CommissioningErrorEnum::kBusyWithOtherAdmin;
@@ -472,9 +462,7 @@ GeneralCommissioningCluster::HandleCommissioningComplete(const DataModel::Invoke
472462
{
473463
MATTER_TRACE_SCOPE("CommissioningComplete", "GeneralCommissioning");
474464

475-
DeviceControlServer * devCtrl = &DeviceLayer::DeviceControlServer::DeviceControlSvr();
476-
auto & failSafe = Server::GetInstance().GetFailSafeContext();
477-
auto & fabricTable = Server::GetInstance().GetFabricTable();
465+
auto & failSafe = mClusterContext.failsafeContext;
478466

479467
ChipLogProgress(FailSafe, "GeneralCommissioning: Received CommissioningComplete");
480468

@@ -490,7 +478,7 @@ GeneralCommissioningCluster::HandleCommissioningComplete(const DataModel::Invoke
490478
}
491479

492480
#if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
493-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
481+
TermsAndConditionsProvider & tcProvider = mClusterContext.termsAndConditionsProvider;
494482

495483
// Ensure required terms and conditions have been accepted, then attempt to commit
496484
Optional<TermsAndConditions> requiredTermsAndConditionsMaybe;
@@ -559,7 +547,7 @@ GeneralCommissioningCluster::HandleCommissioningComplete(const DataModel::Invoke
559547
// Handle NOC commands
560548
if (failSafe.NocCommandHasBeenInvoked())
561549
{
562-
err = fabricTable.CommitPendingFabricData();
550+
err = mClusterContext.fabricTable.CommitPendingFabricData();
563551
if (err != CHIP_NO_ERROR)
564552
{
565553
ChipLogError(FailSafe, "GeneralCommissioning: Failed to commit pending fabric data: %" CHIP_ERROR_FORMAT, err.Format());
@@ -574,7 +562,8 @@ GeneralCommissioningCluster::HandleCommissioningComplete(const DataModel::Invoke
574562

575563
// Disarm the fail-safe and notify the DeviceControlServer
576564
failSafe.DisarmFailSafe();
577-
err = devCtrl->PostCommissioningCompleteEvent(handle->AsSecureSession()->GetPeerNodeId(), handle->GetFabricIndex());
565+
err = mClusterContext.deviceControlServer.PostCommissioningCompleteEvent(handle->AsSecureSession()->GetPeerNodeId(),
566+
handle->GetFabricIndex());
578567
CheckSuccess(err, Failure);
579568

580569
SetBreadCrumb(0);
@@ -588,7 +577,6 @@ GeneralCommissioningCluster::HandleSetRegulatoryConfig(const DataModel::InvokeRe
588577
const Commands::SetRegulatoryConfig::DecodableType & commandData)
589578
{
590579
MATTER_TRACE_SCOPE("SetRegulatoryConfig", "GeneralCommissioning");
591-
DeviceControlServer * server = &DeviceLayer::DeviceControlServer::DeviceControlSvr();
592580
Commands::SetRegulatoryConfigResponse::Type response;
593581
auto & countryCode = commandData.countryCode;
594582

@@ -606,7 +594,7 @@ GeneralCommissioningCluster::HandleSetRegulatoryConfig(const DataModel::InvokeRe
606594
}
607595

608596
uint8_t locationCapability;
609-
if (ConfigurationMgr().GetLocationCapability(locationCapability) != CHIP_NO_ERROR)
597+
if (mClusterContext.configurationManager.GetLocationCapability(locationCapability) != CHIP_NO_ERROR)
610598
{
611599
return Protocols::InteractionModel::Status::Failure;
612600
}
@@ -622,7 +610,7 @@ GeneralCommissioningCluster::HandleSetRegulatoryConfig(const DataModel::InvokeRe
622610
return std::nullopt;
623611
}
624612

625-
CheckSuccess(server->SetRegulatoryConfig(location, countryCode), Failure);
613+
CheckSuccess(mClusterContext.deviceControlServer.SetRegulatoryConfig(location, countryCode), Failure);
626614
SetBreadCrumb(commandData.breadcrumb);
627615
response.errorCode = CommissioningErrorEnum::kOk;
628616
handler->AddResponse(request.path, response);
@@ -636,8 +624,8 @@ GeneralCommissioningCluster::HandleSetTCAcknowledgements(const DataModel::Invoke
636624
{
637625
MATTER_TRACE_SCOPE("SetTCAcknowledgements", "GeneralCommissioning");
638626

639-
auto & failSafeContext = Server::GetInstance().GetFailSafeContext();
640-
TermsAndConditionsProvider & tcProvider = TermsAndConditionsManager::GetInstance();
627+
auto & failSafeContext = mClusterContext.failsafeContext;
628+
TermsAndConditionsProvider & tcProvider = mClusterContext.termsAndConditionsProvider;
641629

642630
Optional<TermsAndConditions> requiredTermsAndConditionsMaybe;
643631
Optional<TermsAndConditions> previousAcceptedTermsAndConditionsMaybe;

0 commit comments

Comments
 (0)