src/app/clusters/energy-evse-server/energy-evse-server.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *    Copyright (c) 2023 Project CHIP Authors
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 #include "energy-evse-server.h"

 #include <app/AttributeAccessInterface.h>
 #include <app/AttributeAccessInterfaceRegistry.h>
 #include <app/ConcreteAttributePath.h>
 #include <app/InteractionModelEngine.h>
 #include <app/util/attribute-storage.h>

 using namespace chip;
 using namespace chip::app;
 using namespace chip::app::DataModel;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::EnergyEvse;
 using namespace chip::app::Clusters::EnergyEvse::Attributes;
 using chip::Protocols::InteractionModel::Status;

 namespace chip {
 namespace app {
 namespace Clusters {
 namespace EnergyEvse {

 CHIP_ERROR Instance::Init()
 {
     ReturnErrorOnFailure(InteractionModelEngine::GetInstance()->RegisterCommandHandler(this));
     VerifyOrReturnError(registerAttributeAccessOverride(this), CHIP_ERROR_INCORRECT_STATE);

     return CHIP_NO_ERROR;
 }

 void Instance::Shutdown()
 {
     InteractionModelEngine::GetInstance()->UnregisterCommandHandler(this);
     unregisterAttributeAccessOverride(this);
 }

 bool Instance::HasFeature(Feature aFeature) const
 {
     return mFeature.Has(aFeature);
 }

 bool Instance::SupportsOptAttr(OptionalAttributes aOptionalAttrs) const
 {
     return mOptionalAttrs.Has(aOptionalAttrs);
 }

 bool Instance::SupportsOptCmd(OptionalCommands aOptionalCmds) const
 {
     return mOptionalCmds.Has(aOptionalCmds);
 }

 // AttributeAccessInterface
 CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
 {
     switch (aPath.mAttributeId)
     {
     case State::Id:
         return aEncoder.Encode(mDelegate.GetState());
     case SupplyState::Id:
         return aEncoder.Encode(mDelegate.GetSupplyState());
     case FaultState::Id:
         return aEncoder.Encode(mDelegate.GetFaultState());
     case ChargingEnabledUntil::Id:
         return aEncoder.Encode(mDelegate.GetChargingEnabledUntil());
     case DischargingEnabledUntil::Id:
         /* V2X */
         return aEncoder.Encode(mDelegate.GetDischargingEnabledUntil());
     case CircuitCapacity::Id:
         return aEncoder.Encode(mDelegate.GetCircuitCapacity());
     case MinimumChargeCurrent::Id:
         return aEncoder.Encode(mDelegate.GetMinimumChargeCurrent());
     case MaximumChargeCurrent::Id:
         return aEncoder.Encode(mDelegate.GetMaximumChargeCurrent());
     case MaximumDischargeCurrent::Id:
         /* V2X */
         return aEncoder.Encode(mDelegate.GetMaximumDischargeCurrent());

     case UserMaximumChargeCurrent::Id:
         return aEncoder.Encode(mDelegate.GetUserMaximumChargeCurrent());
     case RandomizationDelayWindow::Id:
         /* Optional */
         return aEncoder.Encode(mDelegate.GetRandomizationDelayWindow());
     /* PREF - ChargingPreferences attributes */
     case NextChargeStartTime::Id:
         return aEncoder.Encode(mDelegate.GetNextChargeStartTime());
     case NextChargeTargetTime::Id:
         return aEncoder.Encode(mDelegate.GetNextChargeTargetTime());
     case NextChargeRequiredEnergy::Id:
         return aEncoder.Encode(mDelegate.GetNextChargeRequiredEnergy());
     case NextChargeTargetSoC::Id:
         return aEncoder.Encode(mDelegate.GetNextChargeTargetSoC());
     case ApproximateEVEfficiency::Id:
         return aEncoder.Encode(mDelegate.GetApproximateEVEfficiency());
     /* SOC attributes */
     case StateOfCharge::Id:
         return aEncoder.Encode(mDelegate.GetStateOfCharge());
     case BatteryCapacity::Id:
         return aEncoder.Encode(mDelegate.GetBatteryCapacity());
     /* PNC attributes*/
     case VehicleID::Id:
         return aEncoder.Encode(mDelegate.GetVehicleID());
     /* Session SESS attributes */
     case SessionID::Id:
         return aEncoder.Encode(mDelegate.GetSessionID());
     case SessionDuration::Id:
         return aEncoder.Encode(mDelegate.GetSessionDuration());
     case SessionEnergyCharged::Id:
         return aEncoder.Encode(mDelegate.GetSessionEnergyCharged());
     case SessionEnergyDischarged::Id:
         return aEncoder.Encode(mDelegate.GetSessionEnergyDischarged());

     /* FeatureMap - is held locally */
     case FeatureMap::Id:
         return aEncoder.Encode(mFeature);
     }
     /* Allow all other unhandled attributes to fall through to Ember */
     return CHIP_NO_ERROR;
 }

 CHIP_ERROR Instance::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder)
 {
     switch (aPath.mAttributeId)
     {
     case UserMaximumChargeCurrent::Id: {
         // Optional Attribute
         if (!SupportsOptAttr(OptionalAttributes::kSupportsUserMaximumChargingCurrent))
         {
             return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
         }

         int64_t newValue;
         ReturnErrorOnFailure(aDecoder.Decode(newValue));
         ReturnErrorOnFailure(mDelegate.SetUserMaximumChargeCurrent(newValue));
         return CHIP_NO_ERROR;
     }
     case RandomizationDelayWindow::Id: {
         // Optional Attribute
         if (!SupportsOptAttr(OptionalAttributes::kSupportsRandomizationWindow))
         {
             return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
         }
         uint32_t newValue;
         ReturnErrorOnFailure(aDecoder.Decode(newValue));
         ReturnErrorOnFailure(mDelegate.SetRandomizationDelayWindow(newValue));
         return CHIP_NO_ERROR;
     }
     case ApproximateEVEfficiency::Id: {
         // Optional Attribute if ChargingPreferences is supported
         if ((!HasFeature(Feature::kChargingPreferences)) ||
             (!SupportsOptAttr(OptionalAttributes::kSupportsApproximateEvEfficiency)))
         {
             return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
         }
         uint16_t newValue;
         ReturnErrorOnFailure(aDecoder.Decode(newValue));
         ReturnErrorOnFailure(mDelegate.SetApproximateEVEfficiency(MakeNullable(newValue)));
         return CHIP_NO_ERROR;
     }

     default:
         // Unknown attribute; return error.  None of the other attributes for
         // this cluster are writable, so should not be ending up in this code to
         // start with.
         return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
     }
 }

 // CommandHandlerInterface
 CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, CommandIdCallback callback, void * context)
 {
     using namespace Commands;

     for (auto && cmd : {
              Disable::Id,
              EnableCharging::Id,
          })
     {
         VerifyOrExit(callback(cmd, context) == Loop::Continue, /**/);
     }

     if (HasFeature(Feature::kV2x))
     {
         VerifyOrExit(callback(EnableDischarging::Id, context) == Loop::Continue, /**/);
     }

     if (HasFeature(Feature::kChargingPreferences))
     {
         for (auto && cmd : {
                  SetTargets::Id,
                  GetTargets::Id,
                  ClearTargets::Id,
              })
         {
             VerifyOrExit(callback(cmd, context) == Loop::Continue, /**/);
         }
     }

     if (SupportsOptCmd(OptionalCommands::kSupportsStartDiagnostics))
     {
         callback(StartDiagnostics::Id, context);
     }

 exit:
     return CHIP_NO_ERROR;
 }

 void Instance::InvokeCommand(HandlerContext & handlerContext)
 {
     using namespace Commands;

     switch (handlerContext.mRequestPath.mCommandId)
     {
     case Disable::Id:
         HandleCommand<Disable::DecodableType>(
             handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleDisable(ctx, commandData); });
         return;
     case EnableCharging::Id:
         HandleCommand<EnableCharging::DecodableType>(
             handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleEnableCharging(ctx, commandData); });
         return;
     case EnableDischarging::Id:
         if (!HasFeature(Feature::kV2x))
         {
             handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
         }
         else
         {
             HandleCommand<EnableDischarging::DecodableType>(handlerContext, [this](HandlerContext & ctx, const auto & commandData) {
                 HandleEnableDischarging(ctx, commandData);
             });
         }
         return;
     case StartDiagnostics::Id:
         if (!SupportsOptCmd(OptionalCommands::kSupportsStartDiagnostics))
         {
             handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
         }
         else
         {
             HandleCommand<StartDiagnostics::DecodableType>(handlerContext, [this](HandlerContext & ctx, const auto & commandData) {
                 HandleStartDiagnostics(ctx, commandData);
             });
         }
         return;
     case SetTargets::Id:
         if (!HasFeature(Feature::kChargingPreferences))
         {
             handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
         }
         else
         {
             HandleCommand<SetTargets::DecodableType>(
                 handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleSetTargets(ctx, commandData); });
         }
         return;
     case GetTargets::Id:
         if (!HasFeature(Feature::kChargingPreferences))
         {
             handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
         }
         else
         {
             HandleCommand<GetTargets::DecodableType>(
                 handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleGetTargets(ctx, commandData); });
         }
         return;
     case ClearTargets::Id:
         if (!HasFeature(Feature::kChargingPreferences))
         {
             handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
         }
         else
         {
             HandleCommand<ClearTargets::DecodableType>(
                 handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleClearTargets(ctx, commandData); });
         }
         return;
     }
 }

 void Instance::HandleDisable(HandlerContext & ctx, const Commands::Disable::DecodableType & commandData)
 {
     // No parameters for this command
     // Call the delegate
     Status status = mDelegate.Disable();

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }

 void Instance::HandleEnableCharging(HandlerContext & ctx, const Commands::EnableCharging::DecodableType & commandData)
 {
     auto & chargingEnabledUntil = commandData.chargingEnabledUntil;
     auto & minimumChargeCurrent = commandData.minimumChargeCurrent;
     auto & maximumChargeCurrent = commandData.maximumChargeCurrent;

     if ((minimumChargeCurrent < kMinimumChargeCurrent) || (minimumChargeCurrent > kMaximumChargeCurrent))
     {
         ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
         return;
     }

     if ((maximumChargeCurrent < kMinimumChargeCurrent) || (maximumChargeCurrent > kMaximumChargeCurrent))
     {
         ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
         return;
     }

     if (minimumChargeCurrent > maximumChargeCurrent)
     {
         ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
         return;
     }

     // Call the delegate
     Status status = mDelegate.EnableCharging(chargingEnabledUntil, minimumChargeCurrent, maximumChargeCurrent);

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }

 void Instance::HandleEnableDischarging(HandlerContext & ctx, const Commands::EnableDischarging::DecodableType & commandData)
 {

     auto & dischargingEnabledUntil = commandData.dischargingEnabledUntil;
     auto & maximumDischargeCurrent = commandData.maximumDischargeCurrent;

     if ((maximumDischargeCurrent < kMinimumChargeCurrent) || (maximumDischargeCurrent > kMaximumChargeCurrent))
     {
         ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
         return;
     }

     // Call the delegate
     Status status = mDelegate.EnableDischarging(dischargingEnabledUntil, maximumDischargeCurrent);

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }
 void Instance::HandleStartDiagnostics(HandlerContext & ctx, const Commands::StartDiagnostics::DecodableType & commandData)
 {
     // No parameters for this command
     // Call the delegate
     Status status = mDelegate.StartDiagnostics();

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }

 void Instance::HandleSetTargets(HandlerContext & ctx, const Commands::SetTargets::DecodableType & commandData)
 {
     // Call the delegate
     // TODO
     // Status status = mDelegate.SetTargets();
     Status status = Status::UnsupportedCommand;

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }
 void Instance::HandleGetTargets(HandlerContext & ctx, const Commands::GetTargets::DecodableType & commandData)
 {
     // Call the delegate
     // TODO
     // Status status = mDelegate.GetTargets();
     Status status = Status::UnsupportedCommand;

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }
 void Instance::HandleClearTargets(HandlerContext & ctx, const Commands::ClearTargets::DecodableType & commandData)
 {
     // Call the delegate
     // TODO
     // Status status = mDelegate.ClearTargets();
     Status status = Status::UnsupportedCommand;

     ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
 }

 } // namespace EnergyEvse
 } // namespace Clusters
 } // namespace app
 } // namespace chip

 // -----------------------------------------------------------------------------
 // Plugin initialization

 void MatterEnergyEvsePluginServerInitCallback() {}
	/*
	* Copyright (c) 2023 Project CHIP Authors
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "energy-evse-server.h"

	#include <app/AttributeAccessInterface.h>
	#include <app/AttributeAccessInterfaceRegistry.h>
	#include <app/ConcreteAttributePath.h>
	#include <app/InteractionModelEngine.h>
	#include <app/util/attribute-storage.h>

	using namespace chip;
	using namespace chip::app;
	using namespace chip::app::DataModel;
	using namespace chip::app::Clusters;
	using namespace chip::app::Clusters::EnergyEvse;
	using namespace chip::app::Clusters::EnergyEvse::Attributes;
	using chip::Protocols::InteractionModel::Status;

	namespace chip {
	namespace app {
	namespace Clusters {
	namespace EnergyEvse {

	CHIP_ERROR Instance::Init()
	{
	ReturnErrorOnFailure(InteractionModelEngine::GetInstance()->RegisterCommandHandler(this));
	VerifyOrReturnError(registerAttributeAccessOverride(this), CHIP_ERROR_INCORRECT_STATE);

	return CHIP_NO_ERROR;
	}

	void Instance::Shutdown()
	{
	InteractionModelEngine::GetInstance()->UnregisterCommandHandler(this);
	unregisterAttributeAccessOverride(this);
	}

	bool Instance::HasFeature(Feature aFeature) const
	{
	return mFeature.Has(aFeature);
	}

	bool Instance::SupportsOptAttr(OptionalAttributes aOptionalAttrs) const
	{
	return mOptionalAttrs.Has(aOptionalAttrs);
	}

	bool Instance::SupportsOptCmd(OptionalCommands aOptionalCmds) const
	{
	return mOptionalCmds.Has(aOptionalCmds);
	}

	// AttributeAccessInterface
	CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder)
	{
	switch (aPath.mAttributeId)
	{
	case State::Id:
	return aEncoder.Encode(mDelegate.GetState());
	case SupplyState::Id:
	return aEncoder.Encode(mDelegate.GetSupplyState());
	case FaultState::Id:
	return aEncoder.Encode(mDelegate.GetFaultState());
	case ChargingEnabledUntil::Id:
	return aEncoder.Encode(mDelegate.GetChargingEnabledUntil());
	case DischargingEnabledUntil::Id:
	/* V2X */
	return aEncoder.Encode(mDelegate.GetDischargingEnabledUntil());
	case CircuitCapacity::Id:
	return aEncoder.Encode(mDelegate.GetCircuitCapacity());
	case MinimumChargeCurrent::Id:
	return aEncoder.Encode(mDelegate.GetMinimumChargeCurrent());
	case MaximumChargeCurrent::Id:
	return aEncoder.Encode(mDelegate.GetMaximumChargeCurrent());
	case MaximumDischargeCurrent::Id:
	/* V2X */
	return aEncoder.Encode(mDelegate.GetMaximumDischargeCurrent());

	case UserMaximumChargeCurrent::Id:
	return aEncoder.Encode(mDelegate.GetUserMaximumChargeCurrent());
	case RandomizationDelayWindow::Id:
	/* Optional */
	return aEncoder.Encode(mDelegate.GetRandomizationDelayWindow());
	/* PREF - ChargingPreferences attributes */
	case NextChargeStartTime::Id:
	return aEncoder.Encode(mDelegate.GetNextChargeStartTime());
	case NextChargeTargetTime::Id:
	return aEncoder.Encode(mDelegate.GetNextChargeTargetTime());
	case NextChargeRequiredEnergy::Id:
	return aEncoder.Encode(mDelegate.GetNextChargeRequiredEnergy());
	case NextChargeTargetSoC::Id:
	return aEncoder.Encode(mDelegate.GetNextChargeTargetSoC());
	case ApproximateEVEfficiency::Id:
	return aEncoder.Encode(mDelegate.GetApproximateEVEfficiency());
	/* SOC attributes */
	case StateOfCharge::Id:
	return aEncoder.Encode(mDelegate.GetStateOfCharge());
	case BatteryCapacity::Id:
	return aEncoder.Encode(mDelegate.GetBatteryCapacity());
	/* PNC attributes*/
	case VehicleID::Id:
	return aEncoder.Encode(mDelegate.GetVehicleID());
	/* Session SESS attributes */
	case SessionID::Id:
	return aEncoder.Encode(mDelegate.GetSessionID());
	case SessionDuration::Id:
	return aEncoder.Encode(mDelegate.GetSessionDuration());
	case SessionEnergyCharged::Id:
	return aEncoder.Encode(mDelegate.GetSessionEnergyCharged());
	case SessionEnergyDischarged::Id:
	return aEncoder.Encode(mDelegate.GetSessionEnergyDischarged());

	/* FeatureMap - is held locally */
	case FeatureMap::Id:
	return aEncoder.Encode(mFeature);
	}
	/* Allow all other unhandled attributes to fall through to Ember */
	return CHIP_NO_ERROR;
	}

	CHIP_ERROR Instance::Write(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder)
	{
	switch (aPath.mAttributeId)
	{
	case UserMaximumChargeCurrent::Id: {
	// Optional Attribute
	if (!SupportsOptAttr(OptionalAttributes::kSupportsUserMaximumChargingCurrent))
	{
	return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
	}

	int64_t newValue;
	ReturnErrorOnFailure(aDecoder.Decode(newValue));
	ReturnErrorOnFailure(mDelegate.SetUserMaximumChargeCurrent(newValue));
	return CHIP_NO_ERROR;
	}
	case RandomizationDelayWindow::Id: {
	// Optional Attribute
	if (!SupportsOptAttr(OptionalAttributes::kSupportsRandomizationWindow))
	{
	return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
	}
	uint32_t newValue;
	ReturnErrorOnFailure(aDecoder.Decode(newValue));
	ReturnErrorOnFailure(mDelegate.SetRandomizationDelayWindow(newValue));
	return CHIP_NO_ERROR;
	}
	case ApproximateEVEfficiency::Id: {
	// Optional Attribute if ChargingPreferences is supported
	if ((!HasFeature(Feature::kChargingPreferences)) \|\|
	(!SupportsOptAttr(OptionalAttributes::kSupportsApproximateEvEfficiency)))
	{
	return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
	}
	uint16_t newValue;
	ReturnErrorOnFailure(aDecoder.Decode(newValue));
	ReturnErrorOnFailure(mDelegate.SetApproximateEVEfficiency(MakeNullable(newValue)));
	return CHIP_NO_ERROR;
	}

	default:
	// Unknown attribute; return error. None of the other attributes for
	// this cluster are writable, so should not be ending up in this code to
	// start with.
	return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute);
	}
	}

	// CommandHandlerInterface
	CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, CommandIdCallback callback, void * context)
	{
	using namespace Commands;

	for (auto && cmd : {
	Disable::Id,
	EnableCharging::Id,
	})
	{
	VerifyOrExit(callback(cmd, context) == Loop::Continue, /**/);
	}

	if (HasFeature(Feature::kV2x))
	{
	VerifyOrExit(callback(EnableDischarging::Id, context) == Loop::Continue, /**/);
	}

	if (HasFeature(Feature::kChargingPreferences))
	{
	for (auto && cmd : {
	SetTargets::Id,
	GetTargets::Id,
	ClearTargets::Id,
	})
	{
	VerifyOrExit(callback(cmd, context) == Loop::Continue, /**/);
	}
	}

	if (SupportsOptCmd(OptionalCommands::kSupportsStartDiagnostics))
	{
	callback(StartDiagnostics::Id, context);
	}

	exit:
	return CHIP_NO_ERROR;
	}

	void Instance::InvokeCommand(HandlerContext & handlerContext)
	{
	using namespace Commands;

	switch (handlerContext.mRequestPath.mCommandId)
	{
	case Disable::Id:
	HandleCommand<Disable::DecodableType>(
	handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleDisable(ctx, commandData); });
	return;
	case EnableCharging::Id:
	HandleCommand<EnableCharging::DecodableType>(
	handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleEnableCharging(ctx, commandData); });
	return;
	case EnableDischarging::Id:
	if (!HasFeature(Feature::kV2x))
	{
	handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
	}
	else
	{
	HandleCommand<EnableDischarging::DecodableType>(handlerContext, [this](HandlerContext & ctx, const auto & commandData) {
	HandleEnableDischarging(ctx, commandData);
	});
	}
	return;
	case StartDiagnostics::Id:
	if (!SupportsOptCmd(OptionalCommands::kSupportsStartDiagnostics))
	{
	handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
	}
	else
	{
	HandleCommand<StartDiagnostics::DecodableType>(handlerContext, [this](HandlerContext & ctx, const auto & commandData) {
	HandleStartDiagnostics(ctx, commandData);
	});
	}
	return;
	case SetTargets::Id:
	if (!HasFeature(Feature::kChargingPreferences))
	{
	handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
	}
	else
	{
	HandleCommand<SetTargets::DecodableType>(
	handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleSetTargets(ctx, commandData); });
	}
	return;
	case GetTargets::Id:
	if (!HasFeature(Feature::kChargingPreferences))
	{
	handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
	}
	else
	{
	HandleCommand<GetTargets::DecodableType>(
	handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleGetTargets(ctx, commandData); });
	}
	return;
	case ClearTargets::Id:
	if (!HasFeature(Feature::kChargingPreferences))
	{
	handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand);
	}
	else
	{
	HandleCommand<ClearTargets::DecodableType>(
	handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleClearTargets(ctx, commandData); });
	}
	return;
	}
	}

	void Instance::HandleDisable(HandlerContext & ctx, const Commands::Disable::DecodableType & commandData)
	{
	// No parameters for this command
	// Call the delegate
	Status status = mDelegate.Disable();

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}

	void Instance::HandleEnableCharging(HandlerContext & ctx, const Commands::EnableCharging::DecodableType & commandData)
	{
	auto & chargingEnabledUntil = commandData.chargingEnabledUntil;
	auto & minimumChargeCurrent = commandData.minimumChargeCurrent;
	auto & maximumChargeCurrent = commandData.maximumChargeCurrent;

	if ((minimumChargeCurrent < kMinimumChargeCurrent) \|\| (minimumChargeCurrent > kMaximumChargeCurrent))
	{
	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
	return;
	}

	if ((maximumChargeCurrent < kMinimumChargeCurrent) \|\| (maximumChargeCurrent > kMaximumChargeCurrent))
	{
	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
	return;
	}

	if (minimumChargeCurrent > maximumChargeCurrent)
	{
	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
	return;
	}

	// Call the delegate
	Status status = mDelegate.EnableCharging(chargingEnabledUntil, minimumChargeCurrent, maximumChargeCurrent);

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}

	void Instance::HandleEnableDischarging(HandlerContext & ctx, const Commands::EnableDischarging::DecodableType & commandData)
	{

	auto & dischargingEnabledUntil = commandData.dischargingEnabledUntil;
	auto & maximumDischargeCurrent = commandData.maximumDischargeCurrent;

	if ((maximumDischargeCurrent < kMinimumChargeCurrent) \|\| (maximumDischargeCurrent > kMaximumChargeCurrent))
	{
	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError);
	return;
	}

	// Call the delegate
	Status status = mDelegate.EnableDischarging(dischargingEnabledUntil, maximumDischargeCurrent);

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}
	void Instance::HandleStartDiagnostics(HandlerContext & ctx, const Commands::StartDiagnostics::DecodableType & commandData)
	{
	// No parameters for this command
	// Call the delegate
	Status status = mDelegate.StartDiagnostics();

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}

	void Instance::HandleSetTargets(HandlerContext & ctx, const Commands::SetTargets::DecodableType & commandData)
	{
	// Call the delegate
	// TODO
	// Status status = mDelegate.SetTargets();
	Status status = Status::UnsupportedCommand;

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}
	void Instance::HandleGetTargets(HandlerContext & ctx, const Commands::GetTargets::DecodableType & commandData)
	{
	// Call the delegate
	// TODO
	// Status status = mDelegate.GetTargets();
	Status status = Status::UnsupportedCommand;

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}
	void Instance::HandleClearTargets(HandlerContext & ctx, const Commands::ClearTargets::DecodableType & commandData)
	{
	// Call the delegate
	// TODO
	// Status status = mDelegate.ClearTargets();
	Status status = Status::UnsupportedCommand;

	ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status);
	}

	} // namespace EnergyEvse
	} // namespace Clusters
	} // namespace app
	} // namespace chip

	// -----------------------------------------------------------------------------
	// Plugin initialization

	void MatterEnergyEvsePluginServerInitCallback() {}