[SL-UP] Restyling the light switch app (#274)

chirag-silabs · web-flow · commit adec050a3079 · 2025-02-07T19:40:00.000+05:30
diff --git a/examples/light-switch-app/silabs/include/AppEvent.h b/examples/light-switch-app/silabs/include/AppEvent.h
@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include <cstdint>
+
 struct AppEvent;
 typedef void (*EventHandler)(AppEvent *);
 
diff --git a/examples/light-switch-app/silabs/include/AppTask.h b/examples/light-switch-app/silabs/include/AppTask.h
@@ -75,5 +75,4 @@ class AppTask : public BaseApplication
      * @return CHIP_ERROR
      */
     CHIP_ERROR Init();
-
 };
diff --git a/examples/light-switch-app/silabs/include/BindingHandler.h b/examples/light-switch-app/silabs/include/BindingHandler.h
@@ -19,8 +19,8 @@
 #include "app-common/zap-generated/ids/Clusters.h"
 #include "app-common/zap-generated/ids/Commands.h"
 #include "lib/core/CHIPError.h"
-#include <platform/CHIPDeviceLayer.h>
 #include <app/clusters/bindings/bindings.h>
+#include <platform/CHIPDeviceLayer.h>
 #include <variant>
 
 using namespace chip;
@@ -31,15 +31,13 @@ CHIP_ERROR InitBindingHandler();
 void SwitchWorkerFunction(intptr_t context);
 void BindingWorkerFunction(intptr_t context);
 
-
 struct CommandBase
 {
     chip::BitMask<OptionsBitmap> optionsMask;
     chip::BitMask<OptionsBitmap> optionsOverride;
 
     // Constructor to initialize the BitMask
-    CommandBase()
-        : optionsMask(0), optionsOverride(0) {}
+    CommandBase() : optionsMask(0), optionsOverride(0) {}
 };
 
 struct BindingCommandData
@@ -71,4 +69,4 @@ struct BindingCommandData
     };
     // Use std::variant to hold different command types
     std::variant<MoveToLevel, Move, Step, Stop> commandData;
-};
+};
diff --git a/examples/light-switch-app/silabs/include/LightSwitchMgr.h b/examples/light-switch-app/silabs/include/LightSwitchMgr.h
@@ -19,14 +19,14 @@
 
 #pragma once
 
+#include "AppEvent.h"
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app/clusters/bindings/bindings.h>
 #include <app/util/basic-types.h>
+#include <cmsis_os2.h>
 #include <lib/core/CHIPError.h>
 #include <lib/support/CodeUtils.h>
-#include <app/clusters/bindings/bindings.h>
 #include <platform/CHIPDeviceLayer.h>
-#include <app-common/zap-generated/ids/Clusters.h>
-#include "AppEvent.h"
-#include <cmsis_os2.h>
 #include <string>
 
 using namespace chip;
@@ -49,10 +49,7 @@ class LightSwitchMgr
     };
 
     static constexpr Clusters::LevelControl::Commands::Step::Type stepCommand = {
-        .stepSize = 1,
-        .transitionTime = 0,
-        .optionsMask = 0,
-        .optionsOverride = 0
+        .stepSize = 1, .transitionTime = 0, .optionsMask = 0, .optionsOverride = 0
     };
 
     struct Timer
@@ -106,19 +103,19 @@ class LightSwitchMgr
     static LightSwitchMgr sSwitch;
 
     Timer * mLongPressTimer      = nullptr;
-    bool mFunctionButtonPressed  = false;    // True when button0 is pressed, used to trigger factory reset
-    bool mActionButtonPressed    = false;    // True when button1 is pressed, used to initiate toggle or level-up/down
-    bool mActionButtonSuppressed = false;    // True when both button0 and button1 are pressed, used to switch step direction
+    bool mFunctionButtonPressed  = false; // True when button0 is pressed, used to trigger factory reset
+    bool mActionButtonPressed    = false; // True when button1 is pressed, used to initiate toggle or level-up/down
+    bool mActionButtonSuppressed = false; // True when both button0 and button1 are pressed, used to switch step direction
     bool mResetWarning           = false;
 
     // Default Step direction for Level control
-    StepModeEnum stepDirection   = StepModeEnum::kUp;
+    StepModeEnum stepDirection = StepModeEnum::kUp;
 
     static void OnLongPressTimeout(Timer & timer);
     LightSwitchMgr() = default;
 
-     /**
-     * @brief This function will be called when PB0 is 
+    /**
+     * @brief This function will be called when PB0 is
      *        long-pressed to trigger the factory-reset
      */
     void HandleLongPress();
@@ -127,8 +124,8 @@ class LightSwitchMgr
 
     chip::EndpointId mLightSwitchEndpoint   = chip::kInvalidEndpointId;
     chip::EndpointId mGenericSwitchEndpoint = chip::kInvalidEndpointId;
-   
-     /**
+
+    /**
      * @brief Button event processing function
      *        Function triggers a switch action sent to the CHIP task
      *
diff --git a/examples/light-switch-app/silabs/src/BindingHandler.cpp b/examples/light-switch-app/silabs/src/BindingHandler.cpp
@@ -101,38 +101,35 @@ void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const E
 
     switch (data->commandId)
     {
-    case Clusters::LevelControl::Commands::MoveToLevel::Id:
-    {
+    case Clusters::LevelControl::Commands::MoveToLevel::Id: {
         Clusters::LevelControl::Commands::MoveToLevel::Type moveToLevelCommand;
         if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))
         {
             moveToLevelCommand.level           = moveToLevel->level;
             moveToLevelCommand.transitionTime  = moveToLevel->transitionTime;
             moveToLevelCommand.optionsMask     = moveToLevel->optionsMask;
             moveToLevelCommand.optionsOverride = moveToLevel->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         moveToLevelCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, moveToLevelCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::Move::Id:
-    {
+    case Clusters::LevelControl::Commands::Move::Id: {
         Clusters::LevelControl::Commands::Move::Type moveCommand;
         if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))
         {
             moveCommand.moveMode        = move->moveMode;
             moveCommand.rate            = move->rate;
             moveCommand.optionsMask     = move->optionsMask;
             moveCommand.optionsOverride = move->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         moveCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, moveCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::Step::Id:
-    {
+    case Clusters::LevelControl::Commands::Step::Id: {
         Clusters::LevelControl::Commands::Step::Type stepCommand;
         if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))
         {
@@ -141,57 +138,53 @@ void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const E
             stepCommand.transitionTime  = step->transitionTime;
             stepCommand.optionsMask     = step->optionsMask;
             stepCommand.optionsOverride = step->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         stepCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, stepCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::Stop::Id:
-    {
+    case Clusters::LevelControl::Commands::Stop::Id: {
         Clusters::LevelControl::Commands::Stop::Type stopCommand;
         if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))
         {
             stopCommand.optionsMask     = stop->optionsMask;
             stopCommand.optionsOverride = stop->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         stopCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, stopCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id: {
         Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type moveToLevelWithOnOffCommand;
         if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))
         {
             moveToLevelWithOnOffCommand.level           = moveToLevel->level;
             moveToLevelWithOnOffCommand.transitionTime  = moveToLevel->transitionTime;
             moveToLevelWithOnOffCommand.optionsMask     = moveToLevel->optionsMask;
             moveToLevelWithOnOffCommand.optionsOverride = moveToLevel->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         moveToLevelWithOnOffCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, moveToLevelWithOnOffCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::MoveWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::MoveWithOnOff::Id: {
         Clusters::LevelControl::Commands::MoveWithOnOff::Type moveWithOnOffCommand;
         if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))
         {
             moveWithOnOffCommand.moveMode        = move->moveMode;
             moveWithOnOffCommand.rate            = move->rate;
             moveWithOnOffCommand.optionsMask     = move->optionsMask;
             moveWithOnOffCommand.optionsOverride = move->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         moveWithOnOffCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, moveWithOnOffCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::StepWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::StepWithOnOff::Id: {
         Clusters::LevelControl::Commands::StepWithOnOff::Type stepWithOnOffCommand;
         if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))
         {
@@ -200,21 +193,20 @@ void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const E
             stepWithOnOffCommand.transitionTime  = step->transitionTime;
             stepWithOnOffCommand.optionsMask     = step->optionsMask;
             stepWithOnOffCommand.optionsOverride = step->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         stepWithOnOffCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, stepWithOnOffCommand, onSuccess, onFailure);
         }
         break;
     }
 
-    case Clusters::LevelControl::Commands::StopWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::StopWithOnOff::Id: {
         Clusters::LevelControl::Commands::StopWithOnOff::Type stopWithOnOffCommand;
         if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))
         {
             stopWithOnOffCommand.optionsMask     = stop->optionsMask;
             stopWithOnOffCommand.optionsOverride = stop->optionsOverride;
-            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         stopWithOnOffCommand, onSuccess, onFailure);
+            Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),
+                                             binding.remote, stopWithOnOffCommand, onSuccess, onFailure);
         }
         break;
     }
@@ -229,8 +221,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
 
     switch (data->commandId)
     {
-    case Clusters::LevelControl::Commands::MoveToLevel::Id:
-    {
+    case Clusters::LevelControl::Commands::MoveToLevel::Id: {
         Clusters::LevelControl::Commands::MoveToLevel::Type moveToLevelCommand;
         if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))
         {
@@ -243,8 +234,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::Move::Id:
-    {
+    case Clusters::LevelControl::Commands::Move::Id: {
         Clusters::LevelControl::Commands::Move::Type moveCommand;
         if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))
         {
@@ -257,8 +247,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::Step::Id:
-    {
+    case Clusters::LevelControl::Commands::Step::Id: {
         Clusters::LevelControl::Commands::Step::Type stepCommand;
         if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))
         {
@@ -272,8 +261,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::Stop::Id:
-    {
+    case Clusters::LevelControl::Commands::Stop::Id: {
         Clusters::LevelControl::Commands::Stop::Type stopCommand;
         if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))
         {
@@ -284,8 +272,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id: {
         Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type moveToLevelWithOnOffCommand;
         if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))
         {
@@ -298,8 +285,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::MoveWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::MoveWithOnOff::Id: {
         Clusters::LevelControl::Commands::MoveWithOnOff::Type moveWithOnOffCommand;
         if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))
         {
@@ -312,8 +298,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::StepWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::StepWithOnOff::Id: {
         Clusters::LevelControl::Commands::StepWithOnOff::Type stepWithOnOffCommand;
         if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))
         {
@@ -327,8 +312,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb
         break;
     }
 
-    case Clusters::LevelControl::Commands::StopWithOnOff::Id:
-    {
+    case Clusters::LevelControl::Commands::StopWithOnOff::Id: {
         Clusters::LevelControl::Commands::StopWithOnOff::Type stopWithOnOffCommand;
         if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))
         {
diff --git a/examples/light-switch-app/silabs/src/LightSwitchMgr.cpp b/examples/light-switch-app/silabs/src/LightSwitchMgr.cpp
diff --git a/examples/light-switch-app/silabs/src/ShellCommands.cpp b/examples/light-switch-app/silabs/src/ShellCommands.cpp

Original file line number	Diff line number	Diff line change
`@@ -101,38 +101,35 @@ void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const E`
`101`	`101`
`102`	`102`	`switch (data->commandId)`
`103`	`103`	`{`
`104`		`- case Clusters::LevelControl::Commands::MoveToLevel::Id:`
`105`		`- {`
	`104`	`+ case Clusters::LevelControl::Commands::MoveToLevel::Id: {`
`106`	`105`	`Clusters::LevelControl::Commands::MoveToLevel::Type moveToLevelCommand;`
`107`	`106`	`if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))`
`108`	`107`	`{`
`109`	`108`	`moveToLevelCommand.level = moveToLevel->level;`
`110`	`109`	`moveToLevelCommand.transitionTime = moveToLevel->transitionTime;`
`111`	`110`	`moveToLevelCommand.optionsMask = moveToLevel->optionsMask;`
`112`	`111`	`moveToLevelCommand.optionsOverride = moveToLevel->optionsOverride;`
`113`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`114`		`- moveToLevelCommand, onSuccess, onFailure);`
	`112`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`113`	`+ binding.remote, moveToLevelCommand, onSuccess, onFailure);`
`115`	`114`	`}`
`116`	`115`	`break;`
`117`	`116`	`}`
`118`	`117`
`119`		`- case Clusters::LevelControl::Commands::Move::Id:`
`120`		`- {`
	`118`	`+ case Clusters::LevelControl::Commands::Move::Id: {`
`121`	`119`	`Clusters::LevelControl::Commands::Move::Type moveCommand;`
`122`	`120`	`if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))`
`123`	`121`	`{`
`124`	`122`	`moveCommand.moveMode = move->moveMode;`
`125`	`123`	`moveCommand.rate = move->rate;`
`126`	`124`	`moveCommand.optionsMask = move->optionsMask;`
`127`	`125`	`moveCommand.optionsOverride = move->optionsOverride;`
`128`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`129`		`- moveCommand, onSuccess, onFailure);`
	`126`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`127`	`+ binding.remote, moveCommand, onSuccess, onFailure);`
`130`	`128`	`}`
`131`	`129`	`break;`
`132`	`130`	`}`
`133`	`131`
`134`		`- case Clusters::LevelControl::Commands::Step::Id:`
`135`		`- {`
	`132`	`+ case Clusters::LevelControl::Commands::Step::Id: {`
`136`	`133`	`Clusters::LevelControl::Commands::Step::Type stepCommand;`
`137`	`134`	`if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))`
`138`	`135`	`{`
`@@ -141,57 +138,53 @@ void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const E`
`141`	`138`	`stepCommand.transitionTime = step->transitionTime;`
`142`	`139`	`stepCommand.optionsMask = step->optionsMask;`
`143`	`140`	`stepCommand.optionsOverride = step->optionsOverride;`
`144`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`145`		`- stepCommand, onSuccess, onFailure);`
	`141`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`142`	`+ binding.remote, stepCommand, onSuccess, onFailure);`
`146`	`143`	`}`
`147`	`144`	`break;`
`148`	`145`	`}`
`149`	`146`
`150`		`- case Clusters::LevelControl::Commands::Stop::Id:`
`151`		`- {`
	`147`	`+ case Clusters::LevelControl::Commands::Stop::Id: {`
`152`	`148`	`Clusters::LevelControl::Commands::Stop::Type stopCommand;`
`153`	`149`	`if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))`
`154`	`150`	`{`
`155`	`151`	`stopCommand.optionsMask = stop->optionsMask;`
`156`	`152`	`stopCommand.optionsOverride = stop->optionsOverride;`
`157`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`158`		`- stopCommand, onSuccess, onFailure);`
	`153`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`154`	`+ binding.remote, stopCommand, onSuccess, onFailure);`
`159`	`155`	`}`
`160`	`156`	`break;`
`161`	`157`	`}`
`162`	`158`
`163`		`- case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id:`
`164`		`- {`
	`159`	`+ case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id: {`
`165`	`160`	`Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type moveToLevelWithOnOffCommand;`
`166`	`161`	`if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))`
`167`	`162`	`{`
`168`	`163`	`moveToLevelWithOnOffCommand.level = moveToLevel->level;`
`169`	`164`	`moveToLevelWithOnOffCommand.transitionTime = moveToLevel->transitionTime;`
`170`	`165`	`moveToLevelWithOnOffCommand.optionsMask = moveToLevel->optionsMask;`
`171`	`166`	`moveToLevelWithOnOffCommand.optionsOverride = moveToLevel->optionsOverride;`
`172`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`173`		`- moveToLevelWithOnOffCommand, onSuccess, onFailure);`
	`167`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`168`	`+ binding.remote, moveToLevelWithOnOffCommand, onSuccess, onFailure);`
`174`	`169`	`}`
`175`	`170`	`break;`
`176`	`171`	`}`
`177`	`172`
`178`		`- case Clusters::LevelControl::Commands::MoveWithOnOff::Id:`
`179`		`- {`
	`173`	`+ case Clusters::LevelControl::Commands::MoveWithOnOff::Id: {`
`180`	`174`	`Clusters::LevelControl::Commands::MoveWithOnOff::Type moveWithOnOffCommand;`
`181`	`175`	`if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))`
`182`	`176`	`{`
`183`	`177`	`moveWithOnOffCommand.moveMode = move->moveMode;`
`184`	`178`	`moveWithOnOffCommand.rate = move->rate;`
`185`	`179`	`moveWithOnOffCommand.optionsMask = move->optionsMask;`
`186`	`180`	`moveWithOnOffCommand.optionsOverride = move->optionsOverride;`
`187`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`188`		`- moveWithOnOffCommand, onSuccess, onFailure);`
	`181`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`182`	`+ binding.remote, moveWithOnOffCommand, onSuccess, onFailure);`
`189`	`183`	`}`
`190`	`184`	`break;`
`191`	`185`	`}`
`192`	`186`
`193`		`- case Clusters::LevelControl::Commands::StepWithOnOff::Id:`
`194`		`- {`
	`187`	`+ case Clusters::LevelControl::Commands::StepWithOnOff::Id: {`
`195`	`188`	`Clusters::LevelControl::Commands::StepWithOnOff::Type stepWithOnOffCommand;`
`196`	`189`	`if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))`
`197`	`190`	`{`
`@@ -200,21 +193,20 @@ void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const E`
`200`	`193`	`stepWithOnOffCommand.transitionTime = step->transitionTime;`
`201`	`194`	`stepWithOnOffCommand.optionsMask = step->optionsMask;`
`202`	`195`	`stepWithOnOffCommand.optionsOverride = step->optionsOverride;`
`203`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`204`		`- stepWithOnOffCommand, onSuccess, onFailure);`
	`196`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`197`	`+ binding.remote, stepWithOnOffCommand, onSuccess, onFailure);`
`205`	`198`	`}`
`206`	`199`	`break;`
`207`	`200`	`}`
`208`	`201`
`209`		`- case Clusters::LevelControl::Commands::StopWithOnOff::Id:`
`210`		`- {`
	`202`	`+ case Clusters::LevelControl::Commands::StopWithOnOff::Id: {`
`211`	`203`	`Clusters::LevelControl::Commands::StopWithOnOff::Type stopWithOnOffCommand;`
`212`	`204`	`if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))`
`213`	`205`	`{`
`214`	`206`	`stopWithOnOffCommand.optionsMask = stop->optionsMask;`
`215`	`207`	`stopWithOnOffCommand.optionsOverride = stop->optionsOverride;`
`216`		`- Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,`
`217`		`- stopWithOnOffCommand, onSuccess, onFailure);`
	`208`	`+ Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(),`
	`209`	`+ binding.remote, stopWithOnOffCommand, onSuccess, onFailure);`
`218`	`210`	`}`
`219`	`211`	`break;`
`220`	`212`	`}`
`@@ -229,8 +221,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`229`	`221`
`230`	`222`	`switch (data->commandId)`
`231`	`223`	`{`
`232`		`- case Clusters::LevelControl::Commands::MoveToLevel::Id:`
`233`		`- {`
	`224`	`+ case Clusters::LevelControl::Commands::MoveToLevel::Id: {`
`234`	`225`	`Clusters::LevelControl::Commands::MoveToLevel::Type moveToLevelCommand;`
`235`	`226`	`if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))`
`236`	`227`	`{`
`@@ -243,8 +234,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`243`	`234`	`break;`
`244`	`235`	`}`
`245`	`236`
`246`		`- case Clusters::LevelControl::Commands::Move::Id:`
`247`		`- {`
	`237`	`+ case Clusters::LevelControl::Commands::Move::Id: {`
`248`	`238`	`Clusters::LevelControl::Commands::Move::Type moveCommand;`
`249`	`239`	`if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))`
`250`	`240`	`{`
`@@ -257,8 +247,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`257`	`247`	`break;`
`258`	`248`	`}`
`259`	`249`
`260`		`- case Clusters::LevelControl::Commands::Step::Id:`
`261`		`- {`
	`250`	`+ case Clusters::LevelControl::Commands::Step::Id: {`
`262`	`251`	`Clusters::LevelControl::Commands::Step::Type stepCommand;`
`263`	`252`	`if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))`
`264`	`253`	`{`
`@@ -272,8 +261,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`272`	`261`	`break;`
`273`	`262`	`}`
`274`	`263`
`275`		`- case Clusters::LevelControl::Commands::Stop::Id:`
`276`		`- {`
	`264`	`+ case Clusters::LevelControl::Commands::Stop::Id: {`
`277`	`265`	`Clusters::LevelControl::Commands::Stop::Type stopCommand;`
`278`	`266`	`if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))`
`279`	`267`	`{`
`@@ -284,8 +272,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`284`	`272`	`break;`
`285`	`273`	`}`
`286`	`274`
`287`		`- case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id:`
`288`		`- {`
	`275`	`+ case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id: {`
`289`	`276`	`Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type moveToLevelWithOnOffCommand;`
`290`	`277`	`if (auto moveToLevel = std::get_if<BindingCommandData::MoveToLevel>(&data->commandData))`
`291`	`278`	`{`
`@@ -298,8 +285,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`298`	`285`	`break;`
`299`	`286`	`}`
`300`	`287`
`301`		`- case Clusters::LevelControl::Commands::MoveWithOnOff::Id:`
`302`		`- {`
	`288`	`+ case Clusters::LevelControl::Commands::MoveWithOnOff::Id: {`
`303`	`289`	`Clusters::LevelControl::Commands::MoveWithOnOff::Type moveWithOnOffCommand;`
`304`	`290`	`if (auto move = std::get_if<BindingCommandData::Move>(&data->commandData))`
`305`	`291`	`{`
`@@ -312,8 +298,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`312`	`298`	`break;`
`313`	`299`	`}`
`314`	`300`
`315`		`- case Clusters::LevelControl::Commands::StepWithOnOff::Id:`
`316`		`- {`
	`301`	`+ case Clusters::LevelControl::Commands::StepWithOnOff::Id: {`
`317`	`302`	`Clusters::LevelControl::Commands::StepWithOnOff::Type stepWithOnOffCommand;`
`318`	`303`	`if (auto step = std::get_if<BindingCommandData::Step>(&data->commandData))`
`319`	`304`	`{`
`@@ -327,8 +312,7 @@ void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const Emb`
`327`	`312`	`break;`
`328`	`313`	`}`
`329`	`314`
`330`		`- case Clusters::LevelControl::Commands::StopWithOnOff::Id:`
`331`		`- {`
	`315`	`+ case Clusters::LevelControl::Commands::StopWithOnOff::Id: {`
`332`	`316`	`Clusters::LevelControl::Commands::StopWithOnOff::Type stopWithOnOffCommand;`
`333`	`317`	`if (auto stop = std::get_if<BindingCommandData::Stop>(&data->commandData))`
`334`	`318`	`{`