22
22
#include < app-common/zap-generated/attributes/Accessors.h>
23
23
#include < app-common/zap-generated/cluster-enums.h>
24
24
#include < app-common/zap-generated/cluster-objects.h>
25
- #include < app/AttributeAccessInterface.h>
26
- #include < app/AttributeAccessInterfaceRegistry.h>
27
25
#include < app/CommandHandler.h>
26
+ #include < app/CommandHandlerInterfaceRegistry.h>
28
27
#include < app/EventLogging.h>
29
28
#include < app/reporting/reporting.h>
29
+ #include < platform/CHIPDeviceLayer.h>
30
30
#include < platform/PlatformManager.h>
31
31
32
32
#include < memory>
@@ -38,9 +38,9 @@ using chip::Protocols::InteractionModel::Status;
38
38
39
39
namespace {
40
40
41
- NodeId GetNodeId (const CommandHandler * commandObj )
41
+ NodeId GetNodeId (const CommandHandler & commandHandler )
42
42
{
43
- auto descriptor = commandObj-> GetSubjectDescriptor ();
43
+ auto descriptor = commandHandler. GetSubjectDescriptor ();
44
44
45
45
if (descriptor.authMode != Access::AuthMode::kCase )
46
46
{
@@ -49,7 +49,7 @@ NodeId GetNodeId(const CommandHandler * commandObj)
49
49
return descriptor.subject ;
50
50
}
51
51
52
- void AddReverseOpenCommissioningWindowResponse (CommandHandler * commandObj , const ConcreteCommandPath & path,
52
+ void AddReverseOpenCommissioningWindowResponse (CommandHandler & commandHandler , const ConcreteCommandPath & path,
53
53
const Clusters::CommissionerControl::CommissioningWindowParams & params)
54
54
{
55
55
Clusters::CommissionerControl::Commands::ReverseOpenCommissioningWindow::Type response;
@@ -59,30 +59,7 @@ void AddReverseOpenCommissioningWindowResponse(CommandHandler * commandObj, cons
59
59
response.PAKEPasscodeVerifier = params.PAKEPasscodeVerifier ;
60
60
response.salt = params.salt ;
61
61
62
- commandObj->AddResponse (path, response);
63
- }
64
-
65
- void RunDeferredCommissionNode (intptr_t commandArg)
66
- {
67
- auto * params = reinterpret_cast <Clusters::CommissionerControl::CommissioningWindowParams *>(commandArg);
68
-
69
- Clusters::CommissionerControl::Delegate * delegate =
70
- Clusters::CommissionerControl::CommissionerControlServer::Instance ().GetDelegate ();
71
-
72
- if (delegate != nullptr )
73
- {
74
- CHIP_ERROR err = delegate->HandleCommissionNode (*params);
75
- if (err != CHIP_NO_ERROR)
76
- {
77
- ChipLogError (Zcl, " HandleCommissionNode error: %" CHIP_ERROR_FORMAT, err.Format ());
78
- }
79
- }
80
- else
81
- {
82
- ChipLogError (Zcl, " No delegate available for HandleCommissionNode" );
83
- }
84
-
85
- delete params;
62
+ commandHandler.AddResponse (path, response);
86
63
}
87
64
88
65
} // namespace
@@ -92,16 +69,20 @@ namespace app {
92
69
namespace Clusters {
93
70
namespace CommissionerControl {
94
71
95
- CommissionerControlServer CommissionerControlServer::sInstance ;
72
+ CommissionerControlServer::CommissionerControlServer (Delegate * delegate, EndpointId endpointId, ClusterId clusterId) :
73
+ CommandHandlerInterface (MakeOptional(endpointId), clusterId)
74
+ {
75
+ mDelegate = delegate;
76
+ }
96
77
97
- CommissionerControlServer & CommissionerControlServer::Instance ()
78
+ CommissionerControlServer::~CommissionerControlServer ()
98
79
{
99
- return sInstance ;
80
+ CommandHandlerInterfaceRegistry::Instance (). UnregisterCommandHandler ( this ) ;
100
81
}
101
82
102
- CHIP_ERROR CommissionerControlServer::Init (Delegate & delegate )
83
+ CHIP_ERROR CommissionerControlServer::Init ()
103
84
{
104
- mDelegate = &delegate ;
85
+ ReturnErrorOnFailure ( CommandHandlerInterfaceRegistry::Instance (). RegisterCommandHandler ( this )) ;
105
86
return CHIP_NO_ERROR;
106
87
}
107
88
@@ -146,38 +127,53 @@ CommissionerControlServer::GenerateCommissioningRequestResultEvent(EndpointId en
146
127
return error;
147
128
}
148
129
149
- } // namespace CommissionerControl
150
- } // namespace Clusters
151
- } // namespace app
152
- } // namespace chip
130
+ void CommissionerControlServer::InvokeCommand (HandlerContext & handlerContext)
131
+ {
132
+ ChipLogDetail (Zcl, " CommissionerControl: InvokeCommand" );
133
+ switch (handlerContext.mRequestPath .mCommandId )
134
+ {
135
+ case Commands::RequestCommissioningApproval::Id:
136
+ ChipLogDetail (Zcl, " CommissionerControl: Entering RequestCommissioningApproval" );
153
137
154
- bool emberAfCommissionerControlClusterRequestCommissioningApprovalCallback (
155
- app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
156
- const Clusters::CommissionerControl::Commands::RequestCommissioningApproval::DecodableType & commandData)
138
+ CommandHandlerInterface::HandleCommand<Commands::RequestCommissioningApproval::DecodableType>(
139
+ handlerContext, [this ](HandlerContext & ctx, const auto & req) { HandleRequestCommissioningApproval (ctx, req); });
140
+ break ;
141
+
142
+ case Commands::CommissionNode::Id:
143
+ ChipLogDetail (Zcl, " CommissionerControl: Entering CommissionNode" );
144
+
145
+ CommandHandlerInterface::HandleCommand<Commands::CommissionNode::DecodableType>(
146
+ handlerContext, [this ](HandlerContext & ctx, const auto & req) { HandleCommissionNode (ctx, req); });
147
+ break ;
148
+ }
149
+ }
150
+
151
+ void CommissionerControlServer::HandleRequestCommissioningApproval (
152
+ HandlerContext & ctx, const Commands::RequestCommissioningApproval::DecodableType & req)
157
153
{
158
154
CHIP_ERROR err = CHIP_NO_ERROR;
159
155
Status status = Status::Success;
160
156
161
157
ChipLogProgress (Zcl, " Received command to request commissioning approval" );
162
158
163
- auto sourceNodeId = GetNodeId (commandObj );
159
+ auto sourceNodeId = GetNodeId (ctx. mCommandHandler );
164
160
165
161
// Check if the command is executed via a CASE session
166
162
if (sourceNodeId == kUndefinedNodeId )
167
163
{
168
164
ChipLogError (Zcl, " Commissioning approval request not executed via CASE session, failing with UNSUPPORTED_ACCESS" );
169
- commandObj-> AddStatus (commandPath , Status::UnsupportedAccess);
170
- return true ;
165
+ ctx. mCommandHandler . AddStatus (ctx. mRequestPath , Status::UnsupportedAccess);
166
+ return ;
171
167
}
172
168
173
- auto fabricIndex = commandObj-> GetAccessingFabricIndex ();
174
- auto requestId = commandData .requestID ;
175
- auto vendorId = commandData .vendorID ;
176
- auto productId = commandData .productID ;
169
+ auto fabricIndex = ctx. mCommandHandler . GetAccessingFabricIndex ();
170
+ auto requestId = req .requestID ;
171
+ auto vendorId = req .vendorID ;
172
+ auto productId = req .productID ;
177
173
178
- // The label assigned from commandData need to be stored in CommissionerControl::Delegate which ensure that the backing buffer
174
+ // The label assigned from req need to be stored in CommissionerControl::Delegate which ensure that the backing buffer
179
175
// of it has a valid lifespan during fabric sync setup process.
180
- auto & label = commandData .label ;
176
+ auto & label = req .label ;
181
177
182
178
// Create a CommissioningApprovalRequest struct and populate it with the command data
183
179
Clusters::CommissionerControl::CommissioningApprovalRequest request = { .requestId = requestId,
@@ -187,86 +183,93 @@ bool emberAfCommissionerControlClusterRequestCommissioningApprovalCallback(
187
183
.fabricIndex = fabricIndex,
188
184
.label = label };
189
185
190
- Clusters::CommissionerControl::Delegate * delegate =
191
- Clusters::CommissionerControl::CommissionerControlServer::Instance ().GetDelegate ();
192
-
193
- VerifyOrExit (delegate != nullptr , err = CHIP_ERROR_INCORRECT_STATE);
186
+ VerifyOrExit (mDelegate != nullptr , err = CHIP_ERROR_INCORRECT_STATE);
194
187
195
188
// Handle commissioning approval request
196
- err = delegate ->HandleCommissioningApprovalRequest (request);
189
+ err = mDelegate ->HandleCommissioningApprovalRequest (request);
197
190
198
191
exit :
199
192
if (err != CHIP_NO_ERROR)
200
193
{
201
- ChipLogError (Zcl, " emberAfCommissionerControlClusterRequestCommissioningApprovalCallback error: %" CHIP_ERROR_FORMAT,
202
- err.Format ());
194
+ ChipLogError (Zcl, " HandleRequestCommissioningApproval error: %" CHIP_ERROR_FORMAT, err.Format ());
203
195
status = StatusIB (err).mStatus ;
204
196
}
205
197
206
- commandObj->AddStatus (commandPath, status);
207
- return true ;
198
+ ctx.mCommandHandler .AddStatus (ctx.mRequestPath , status);
208
199
}
209
200
210
- bool emberAfCommissionerControlClusterCommissionNodeCallback (
211
- app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
212
- const Clusters::CommissionerControl::Commands::CommissionNode::DecodableType & commandData)
201
+ void CommissionerControlServer::HandleCommissionNode (HandlerContext & ctx, const Commands::CommissionNode::DecodableType & req)
213
202
{
214
203
CHIP_ERROR err = CHIP_NO_ERROR;
215
204
216
205
ChipLogProgress (Zcl, " Received command to commission node" );
217
206
218
- auto sourceNodeId = GetNodeId (commandObj );
207
+ auto sourceNodeId = GetNodeId (ctx. mCommandHandler );
219
208
220
209
// Constraint on responseTimeoutSeconds is [30; 120] seconds
221
- if ((commandData .responseTimeoutSeconds < 30 ) || (commandData .responseTimeoutSeconds > 120 ))
210
+ if ((req .responseTimeoutSeconds < 30 ) || (req .responseTimeoutSeconds > 120 ))
222
211
{
223
212
ChipLogError (Zcl, " Invalid responseTimeoutSeconds for CommissionNode." );
224
- commandObj-> AddStatus (commandPath , Status::ConstraintError);
225
- return true ;
213
+ ctx. mCommandHandler . AddStatus (ctx. mRequestPath , Status::ConstraintError);
214
+ return ;
226
215
}
227
216
228
217
// Check if the command is executed via a CASE session
229
218
if (sourceNodeId == kUndefinedNodeId )
230
219
{
231
220
ChipLogError (Zcl, " Commission node request not executed via CASE session, failing with UNSUPPORTED_ACCESS" );
232
- commandObj-> AddStatus (commandPath , Status::UnsupportedAccess);
233
- return true ;
221
+ ctx. mCommandHandler . AddStatus (ctx. mRequestPath , Status::UnsupportedAccess);
222
+ return ;
234
223
}
235
224
236
- auto requestId = commandData .requestID ;
237
-
225
+ auto requestId = req .requestID ;
226
+ auto delegate = mDelegate ;
238
227
auto commissioningWindowParams = std::make_unique<Clusters::CommissionerControl::CommissioningWindowParams>();
239
228
240
- Clusters::CommissionerControl::Delegate * delegate =
241
- Clusters::CommissionerControl::CommissionerControlServer::Instance ().GetDelegate ();
242
-
243
- VerifyOrExit (delegate != nullptr , err = CHIP_ERROR_INCORRECT_STATE);
229
+ VerifyOrExit (mDelegate != nullptr , err = CHIP_ERROR_INCORRECT_STATE);
244
230
245
231
// Validate the commission node command.
246
- err = delegate ->ValidateCommissionNodeCommand (sourceNodeId, requestId);
232
+ err = mDelegate ->ValidateCommissionNodeCommand (sourceNodeId, requestId);
247
233
SuccessOrExit (err);
248
234
249
235
// Populate the parameters for the commissioning window
250
- err = delegate ->GetCommissioningWindowParams (*commissioningWindowParams);
236
+ err = mDelegate ->GetCommissioningWindowParams (*commissioningWindowParams);
251
237
SuccessOrExit (err);
252
238
253
239
// Add the response for the commissioning window.
254
- AddReverseOpenCommissioningWindowResponse (commandObj, commandPath , *commissioningWindowParams);
240
+ AddReverseOpenCommissioningWindowResponse (ctx. mCommandHandler , ctx. mRequestPath , *commissioningWindowParams);
255
241
256
242
// Schedule the deferred reverse commission node task
257
- DeviceLayer::PlatformMgr ().ScheduleWork (RunDeferredCommissionNode,
258
- reinterpret_cast <intptr_t >(commissioningWindowParams.release ()));
243
+ DeviceLayer::SystemLayer ().ScheduleLambda ([delegate, params = commissioningWindowParams.release ()]() {
244
+ if (delegate != nullptr )
245
+ {
246
+ CHIP_ERROR error = delegate->HandleCommissionNode (*params);
247
+ if (error != CHIP_NO_ERROR)
248
+ {
249
+ ChipLogError (Zcl, " HandleCommissionNode error: %" CHIP_ERROR_FORMAT, error.Format ());
250
+ }
251
+ }
252
+ else
253
+ {
254
+ ChipLogError (Zcl, " No delegate available for HandleCommissionNode" );
255
+ }
256
+
257
+ delete params;
258
+ });
259
259
260
260
exit :
261
261
if (err != CHIP_NO_ERROR)
262
262
{
263
- ChipLogError (Zcl, " emberAfCommissionerControlClusterCommissionNodeCallback error: %" CHIP_ERROR_FORMAT, err.Format ());
264
- commandObj-> AddStatus (commandPath , StatusIB (err).mStatus );
263
+ ChipLogError (Zcl, " HandleCommissionNode error: %" CHIP_ERROR_FORMAT, err.Format ());
264
+ ctx. mCommandHandler . AddStatus (ctx. mRequestPath , StatusIB (err).mStatus );
265
265
}
266
-
267
- return true ;
268
266
}
269
267
268
+ } // namespace CommissionerControl
269
+ } // namespace Clusters
270
+ } // namespace app
271
+ } // namespace chip
272
+
270
273
void MatterCommissionerControlPluginServerInitCallback ()
271
274
{
272
275
ChipLogProgress (Zcl, " Initializing Commissioner Control cluster." );
0 commit comments