src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-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.
  */

 /**
  * @file
  *   Routines for the Smoke CO Alarm Server plugin.
  *
  */

 #include "smoke-co-alarm-server.h"

 #include <app-common/zap-generated/attributes/Accessors.h>
 #include <app/EventLogging.h>

 using namespace chip;
 using namespace chip::app;
 using namespace chip::app::Clusters::SmokeCoAlarm;
 using namespace chip::app::Clusters::SmokeCoAlarm::Attributes;
 using chip::Protocols::InteractionModel::Status;

 SmokeCoAlarmServer SmokeCoAlarmServer::sInstance;

 /**********************************************************
  * SmokeCoAlarmServer public methods
  *********************************************************/

 SmokeCoAlarmServer & SmokeCoAlarmServer::Instance()
 {
     return sInstance;
 }

 void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId,
                                                      const std::array<ExpressedStateEnum, kPriorityOrderLength> & priorityOrder)
 {
     for (ExpressedStateEnum priority : priorityOrder)
     {
         AlarmStateEnum alarmState          = AlarmStateEnum::kNormal;
         EndOfServiceEnum endOfServiceState = EndOfServiceEnum::kNormal;
         bool active                        = false;
         bool success                       = false;

         switch (priority)
         {
         case ExpressedStateEnum::kSmokeAlarm:
             success = GetSmokeState(endpointId, alarmState);
             break;
         case ExpressedStateEnum::kCOAlarm:
             success = GetCOState(endpointId, alarmState);
             break;
         case ExpressedStateEnum::kBatteryAlert:
             success = GetBatteryAlert(endpointId, alarmState);
             break;
         case ExpressedStateEnum::kTesting:
             success = GetTestInProgress(endpointId, active);
             break;
         case ExpressedStateEnum::kHardwareFault:
             success = GetHardwareFaultAlert(endpointId, active);
             break;
         case ExpressedStateEnum::kEndOfService:
             success = GetEndOfServiceAlert(endpointId, endOfServiceState);
             break;
         case ExpressedStateEnum::kInterconnectSmoke:
             success = GetInterconnectSmokeAlarm(endpointId, alarmState);
             break;
         case ExpressedStateEnum::kInterconnectCO:
             success = GetInterconnectCOAlarm(endpointId, alarmState);
             break;
         default:
             break;
         }

         if (success && ((alarmState != AlarmStateEnum::kNormal) || (endOfServiceState != EndOfServiceEnum::kNormal) || active))
         {
             SetExpressedState(endpointId, priority);
             return;
         }
     }

     SetExpressedState(endpointId, ExpressedStateEnum::kNormal);
 }

 bool SmokeCoAlarmServer::RequestSelfTest(EndpointId endpointId)
 {
     ExpressedStateEnum expressedState;
     VerifyOrReturnValue(GetExpressedState(endpointId, expressedState), false);

     // If the value is busy then return busy
     if (expressedState == ExpressedStateEnum::kSmokeAlarm || expressedState == ExpressedStateEnum::kCOAlarm ||
         expressedState == ExpressedStateEnum::kTesting || expressedState == ExpressedStateEnum::kInterconnectSmoke ||
         expressedState == ExpressedStateEnum::kInterconnectCO)
     {
         return false;
     }

     VerifyOrReturnValue(SetTestInProgress(endpointId, true), false);
     SetExpressedState(endpointId, ExpressedStateEnum::kTesting);

     emberAfPluginSmokeCoAlarmSelfTestRequestCommand(endpointId);

     return true;
 }

 bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState)
 {
     AlarmStateEnum alarmState;
     VerifyOrReturnValue(GetAttribute(endpointId, SmokeState::Id, SmokeState::Get, alarmState), false);
     VerifyOrReturnValue(alarmState != newSmokeState, true);

     VerifyOrReturnValue(SetAttribute(endpointId, SmokeState::Id, SmokeState::Set, newSmokeState), false);
     if (newSmokeState == AlarmStateEnum::kWarning || newSmokeState == AlarmStateEnum::kCritical)
     {
         Events::SmokeAlarm::Type event{ newSmokeState };
         SendEvent(endpointId, event);
     }

     if (newSmokeState == AlarmStateEnum::kCritical)
     {
         SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetCOState(EndpointId endpointId, AlarmStateEnum newCOState)
 {
     AlarmStateEnum alarmState;
     VerifyOrReturnValue(GetAttribute(endpointId, COState::Id, COState::Get, alarmState), false);
     VerifyOrReturnValue(alarmState != newCOState, true);

     VerifyOrReturnValue(SetAttribute(endpointId, COState::Id, COState::Set, newCOState), false);
     if (newCOState == AlarmStateEnum::kWarning || newCOState == AlarmStateEnum::kCritical)
     {
         Events::COAlarm::Type event{ newCOState };
         SendEvent(endpointId, event);
     }

     if (newCOState == AlarmStateEnum::kCritical)
     {
         SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetBatteryAlert(EndpointId endpointId, AlarmStateEnum newBatteryAlert)
 {
     AlarmStateEnum alarmState;
     VerifyOrReturnValue(GetAttribute(endpointId, BatteryAlert::Id, BatteryAlert::Get, alarmState), false);
     VerifyOrReturnValue(alarmState != newBatteryAlert, true);

     VerifyOrReturnValue(SetAttribute(endpointId, BatteryAlert::Id, BatteryAlert::Set, newBatteryAlert), false);
     if (newBatteryAlert == AlarmStateEnum::kWarning || newBatteryAlert == AlarmStateEnum::kCritical)
     {
         Events::LowBattery::Type event{ newBatteryAlert };
         SendEvent(endpointId, event);
     }

     if (newBatteryAlert == AlarmStateEnum::kCritical)
     {
         SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetDeviceMuted(EndpointId endpointId, MuteStateEnum newDeviceMuted)
 {
     MuteStateEnum deviceMuted;
     VerifyOrReturnValue(GetAttribute(endpointId, DeviceMuted::Id, DeviceMuted::Get, deviceMuted), false);
     VerifyOrReturnValue(deviceMuted != newDeviceMuted, true);

     if (newDeviceMuted == MuteStateEnum::kMuted)
     {
         AlarmStateEnum alarmState;

         // If the attribute has been read and the attribute is Critical, return false

         bool success = GetSmokeState(endpointId, alarmState);
         VerifyOrReturnValue(!success || alarmState != AlarmStateEnum::kCritical, false);

         success = GetCOState(endpointId, alarmState);
         VerifyOrReturnValue(!success || alarmState != AlarmStateEnum::kCritical, false);

         success = GetBatteryAlert(endpointId, alarmState);
         VerifyOrReturnValue(!success || alarmState != AlarmStateEnum::kCritical, false);

         success = GetInterconnectSmokeAlarm(endpointId, alarmState);
         VerifyOrReturnValue(!success || alarmState != AlarmStateEnum::kCritical, false);

         success = GetInterconnectCOAlarm(endpointId, alarmState);
         VerifyOrReturnValue(!success || alarmState != AlarmStateEnum::kCritical, false);
     }

     VerifyOrReturnValue(SetAttribute(endpointId, DeviceMuted::Id, DeviceMuted::Set, newDeviceMuted), false);
     if (newDeviceMuted == MuteStateEnum::kMuted)
     {
         Events::AlarmMuted::Type event{};
         SendEvent(endpointId, event);
     }
     else if (newDeviceMuted == MuteStateEnum::kNotMuted)
     {
         Events::MuteEnded::Type event{};
         SendEvent(endpointId, event);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetTestInProgress(EndpointId endpointId, bool newTestInProgress)
 {
     bool active;
     VerifyOrReturnValue(GetAttribute(endpointId, TestInProgress::Id, TestInProgress::Get, active), false);
     VerifyOrReturnValue(active != newTestInProgress, true);

     VerifyOrReturnValue(SetAttribute(endpointId, TestInProgress::Id, TestInProgress::Set, newTestInProgress), false);
     if (!newTestInProgress)
     {
         Events::SelfTestComplete::Type event{};
         SendEvent(endpointId, event);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetHardwareFaultAlert(EndpointId endpointId, bool newHardwareFaultAlert)
 {
     bool active;
     VerifyOrReturnValue(GetAttribute(endpointId, HardwareFaultAlert::Id, HardwareFaultAlert::Get, active), false);
     VerifyOrReturnValue(active != newHardwareFaultAlert, true);

     VerifyOrReturnValue(SetAttribute(endpointId, HardwareFaultAlert::Id, HardwareFaultAlert::Set, newHardwareFaultAlert), false);
     if (newHardwareFaultAlert)
     {
         Events::HardwareFault::Type event{};
         SendEvent(endpointId, event);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetEndOfServiceAlert(EndpointId endpointId, EndOfServiceEnum newEndOfServiceAlert)
 {
     EndOfServiceEnum endOfServiceState;
     VerifyOrReturnValue(GetAttribute(endpointId, EndOfServiceAlert::Id, EndOfServiceAlert::Get, endOfServiceState), false);
     VerifyOrReturnValue(endOfServiceState != newEndOfServiceAlert, true);

     VerifyOrReturnValue(SetAttribute(endpointId, EndOfServiceAlert::Id, EndOfServiceAlert::Set, newEndOfServiceAlert), false);
     if (newEndOfServiceAlert == EndOfServiceEnum::kExpired)
     {
         Events::EndOfService::Type event{};
         SendEvent(endpointId, event);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetInterconnectSmokeAlarm(EndpointId endpointId, AlarmStateEnum newInterconnectSmokeAlarm)
 {
     AlarmStateEnum alarmState;
     VerifyOrReturnValue(GetAttribute(endpointId, InterconnectSmokeAlarm::Id, InterconnectSmokeAlarm::Get, alarmState), false);
     VerifyOrReturnValue(alarmState != newInterconnectSmokeAlarm, true);

     VerifyOrReturnValue(
         SetAttribute(endpointId, InterconnectSmokeAlarm::Id, InterconnectSmokeAlarm::Set, newInterconnectSmokeAlarm), false);
     if (newInterconnectSmokeAlarm == AlarmStateEnum::kWarning || newInterconnectSmokeAlarm == AlarmStateEnum::kCritical)
     {
         Events::InterconnectSmokeAlarm::Type event{ newInterconnectSmokeAlarm };
         SendEvent(endpointId, event);
     }

     if (newInterconnectSmokeAlarm == AlarmStateEnum::kCritical)
     {
         SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetInterconnectCOAlarm(EndpointId endpointId, AlarmStateEnum newInterconnectCOAlarm)
 {
     AlarmStateEnum alarmState;
     VerifyOrReturnValue(GetAttribute(endpointId, InterconnectCOAlarm::Id, InterconnectCOAlarm::Get, alarmState), false);
     VerifyOrReturnValue(alarmState != newInterconnectCOAlarm, true);

     VerifyOrReturnValue(SetAttribute(endpointId, InterconnectCOAlarm::Id, InterconnectCOAlarm::Set, newInterconnectCOAlarm), false);
     if (newInterconnectCOAlarm == AlarmStateEnum::kWarning || newInterconnectCOAlarm == AlarmStateEnum::kCritical)
     {
         Events::InterconnectCOAlarm::Type event{ newInterconnectCOAlarm };
         SendEvent(endpointId, event);
     }

     if (newInterconnectCOAlarm == AlarmStateEnum::kCritical)
     {
         SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
     }

     return true;
 }

 bool SmokeCoAlarmServer::SetContaminationState(EndpointId endpointId, ContaminationStateEnum newContaminationState)
 {
     ContaminationStateEnum contaminationState;
     VerifyOrReturnValue(GetAttribute(endpointId, ContaminationState::Id, ContaminationState::Get, contaminationState), false);
     VerifyOrReturnValue(contaminationState != newContaminationState, true);

     VerifyOrReturnValue(SetAttribute(endpointId, ContaminationState::Id, ContaminationState::Set, newContaminationState), false);

     return true;
 }

 bool SmokeCoAlarmServer::SetSmokeSensitivityLevel(EndpointId endpointId, SensitivityEnum newSmokeSensitivityLevel)
 {
     SensitivityEnum sensitivity;
     VerifyOrReturnValue(GetAttribute(endpointId, SmokeSensitivityLevel::Id, SmokeSensitivityLevel::Get, sensitivity), false);
     VerifyOrReturnValue(sensitivity != newSmokeSensitivityLevel, true);

     VerifyOrReturnValue(SetAttribute(endpointId, SmokeSensitivityLevel::Id, SmokeSensitivityLevel::Set, newSmokeSensitivityLevel),
                         false);

     return true;
 }

 bool SmokeCoAlarmServer::GetExpressedState(chip ::EndpointId endpointId, ExpressedStateEnum & expressedState)
 {
     return GetAttribute(endpointId, ExpressedState::Id, ExpressedState::Get, expressedState);
 }

 bool SmokeCoAlarmServer::GetSmokeState(EndpointId endpointId, AlarmStateEnum & smokeState)
 {
     return GetAttribute(endpointId, SmokeState::Id, SmokeState::Get, smokeState);
 }

 bool SmokeCoAlarmServer::GetCOState(EndpointId endpointId, AlarmStateEnum & coState)
 {
     return GetAttribute(endpointId, COState::Id, COState::Get, coState);
 }

 bool SmokeCoAlarmServer::GetBatteryAlert(EndpointId endpointId, AlarmStateEnum & batteryAlert)
 {
     return GetAttribute(endpointId, BatteryAlert::Id, BatteryAlert::Get, batteryAlert);
 }

 bool SmokeCoAlarmServer::GetDeviceMuted(EndpointId endpointId, MuteStateEnum & deviceMuted)
 {
     return GetAttribute(endpointId, DeviceMuted::Id, DeviceMuted::Get, deviceMuted);
 }

 bool SmokeCoAlarmServer::GetTestInProgress(EndpointId endpointId, bool & testInProgress)
 {
     return GetAttribute(endpointId, TestInProgress::Id, TestInProgress::Get, testInProgress);
 }

 bool SmokeCoAlarmServer::GetHardwareFaultAlert(EndpointId endpointId, bool & hardwareFaultAlert)
 {
     return GetAttribute(endpointId, HardwareFaultAlert::Id, HardwareFaultAlert::Get, hardwareFaultAlert);
 }

 bool SmokeCoAlarmServer::GetEndOfServiceAlert(EndpointId endpointId, EndOfServiceEnum & endOfServiceAlert)
 {
     return GetAttribute(endpointId, EndOfServiceAlert::Id, EndOfServiceAlert::Get, endOfServiceAlert);
 }

 bool SmokeCoAlarmServer::GetInterconnectSmokeAlarm(EndpointId endpointId, AlarmStateEnum & interconnectSmokeAlarm)
 {
     return GetAttribute(endpointId, InterconnectSmokeAlarm::Id, InterconnectSmokeAlarm::Get, interconnectSmokeAlarm);
 }

 bool SmokeCoAlarmServer::GetInterconnectCOAlarm(EndpointId endpointId, AlarmStateEnum & interconnectCOAlarm)
 {
     return GetAttribute(endpointId, InterconnectCOAlarm::Id, InterconnectCOAlarm::Get, interconnectCOAlarm);
 }

 bool SmokeCoAlarmServer::GetContaminationState(EndpointId endpointId, ContaminationStateEnum & contaminationState)
 {
     return GetAttribute(endpointId, ContaminationState::Id, ContaminationState::Get, contaminationState);
 }

 bool SmokeCoAlarmServer::GetSmokeSensitivityLevel(EndpointId endpointId, SensitivityEnum & smokeSensitivityLevel)
 {
     return GetAttribute(endpointId, SmokeSensitivityLevel::Id, SmokeSensitivityLevel::Get, smokeSensitivityLevel);
 }

 bool SmokeCoAlarmServer::GetExpiryDate(EndpointId endpointId, uint32_t & expiryDate)
 {
     return GetAttribute(endpointId, ExpiryDate::Id, ExpiryDate::Get, expiryDate);
 }

 chip::BitFlags<Feature> SmokeCoAlarmServer::GetFeatures(EndpointId endpointId)
 {
     chip::BitFlags<Feature> featureMap;
     if (!GetAttribute(endpointId, FeatureMap::Id, FeatureMap::Get, *featureMap.RawStorage()))
     {
         ChipLogError(Zcl, "Unable to get the Smoke CO Alarm feature map: attribute read error");
         featureMap.ClearAll();
     }
     return featureMap;
 }

 /**********************************************************
  * SmokeCoAlarmServer private methods
  *********************************************************/

 void SmokeCoAlarmServer::SetExpressedState(EndpointId endpointId, ExpressedStateEnum newExpressedState)
 {
     ExpressedStateEnum expressedState;
     VerifyOrReturn(GetAttribute(endpointId, ExpressedState::Id, ExpressedState::Get, expressedState));
     VerifyOrReturn(expressedState != newExpressedState);

     VerifyOrReturn(SetAttribute(endpointId, ExpressedState::Id, ExpressedState::Set, newExpressedState));
     if (newExpressedState == ExpressedStateEnum::kNormal)
     {
         Events::AllClear::Type event{};
         SendEvent(endpointId, event);
     }
 }

 void SmokeCoAlarmServer::HandleRemoteSelfTestRequest(CommandHandler * commandObj, const ConcreteCommandPath & commandPath)
 {
     EndpointId endpointId = commandPath.mEndpointId;

     ExpressedStateEnum expressedState;
     VerifyOrReturn(GetExpressedState(endpointId, expressedState), commandObj->AddStatus(commandPath, Status::Failure));

     // If the value is busy then return busy
     if (expressedState == ExpressedStateEnum::kSmokeAlarm || expressedState == ExpressedStateEnum::kCOAlarm ||
         expressedState == ExpressedStateEnum::kTesting || expressedState == ExpressedStateEnum::kInterconnectSmoke ||
         expressedState == ExpressedStateEnum::kInterconnectCO)
     {
         commandObj->AddStatus(commandPath, Status::Busy);
         return;
     }

     VerifyOrReturn(SetTestInProgress(endpointId, true), commandObj->AddStatus(commandPath, Status::Failure));
     SetExpressedState(endpointId, ExpressedStateEnum::kTesting);

     emberAfPluginSmokeCoAlarmSelfTestRequestCommand(endpointId);

     commandObj->AddStatus(commandPath, Status::Success);
 }

 template <typename T>
 void SmokeCoAlarmServer::SendEvent(EndpointId endpointId, T & event)
 {
     EventNumber eventNumber;
     auto err = LogEvent(event, endpointId, eventNumber);

     if (CHIP_NO_ERROR != err)
     {
         ChipLogError(Zcl, "Failed to log event: err=%" CHIP_ERROR_FORMAT ", event_id=" ChipLogFormatMEI, err.Format(),
                      ChipLogValueMEI(event.GetEventId()));
     }
 }

 template <typename T>
 bool SmokeCoAlarmServer::GetAttribute(EndpointId endpointId, AttributeId attributeId,
                                       Status (*getFn)(EndpointId endpointId, T * value), T & value) const
 {
     Status status          = getFn(endpointId, &value);
     bool success           = (Status::Success == status);
     bool unsupportedStatus = (Status::UnsupportedAttribute == status);

     if (unsupportedStatus)
     {
         ChipLogProgress(Zcl, "Read unsupported SmokeCOAlarm attribute: attribute=" ChipLogFormatMEI, ChipLogValueMEI(attributeId));
     }
     else if (!success)
     {
         ChipLogError(Zcl, "Failed to read SmokeCOAlarm attribute: attribute=" ChipLogFormatMEI ", status=0x%x",
                      ChipLogValueMEI(attributeId), to_underlying(status));
     }
     return success;
 }

 template <typename T>
 bool SmokeCoAlarmServer::SetAttribute(EndpointId endpointId, AttributeId attributeId,
                                       Status (*setFn)(EndpointId endpointId, T value), T value)
 {
     Status status = setFn(endpointId, value);
     bool success  = (Status::Success == status);

     if (!success)
     {
         ChipLogError(Zcl, "Failed to write SmokeCOAlarm attribute: attribute=" ChipLogFormatMEI ", status=0x%x",
                      ChipLogValueMEI(attributeId), to_underlying(status));
     }
     return success;
 }

 // =============================================================================
 // Cluster commands callbacks
 // =============================================================================

 bool emberAfSmokeCoAlarmClusterSelfTestRequestCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
                                                        const Commands::SelfTestRequest::DecodableType & commandData)
 {
     SmokeCoAlarmServer::Instance().HandleRemoteSelfTestRequest(commandObj, commandPath);
     return true;
 }

 void MatterSmokeCoAlarmPluginServerInitCallback() {}
	/**
	*
	* 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.
	*/

	/**
	* @file
	* Routines for the Smoke CO Alarm Server plugin.
	*
	*/

	#include "smoke-co-alarm-server.h"

	#include <app-common/zap-generated/attributes/Accessors.h>
	#include <app/EventLogging.h>

	using namespace chip;
	using namespace chip::app;
	using namespace chip::app::Clusters::SmokeCoAlarm;
	using namespace chip::app::Clusters::SmokeCoAlarm::Attributes;
	using chip::Protocols::InteractionModel::Status;

	SmokeCoAlarmServer SmokeCoAlarmServer::sInstance;

	/**********************************************************
	* SmokeCoAlarmServer public methods
	*********************************************************/

	SmokeCoAlarmServer & SmokeCoAlarmServer::Instance()
	{
	return sInstance;
	}

	void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId,
	const std::array<ExpressedStateEnum, kPriorityOrderLength> & priorityOrder)
	{
	for (ExpressedStateEnum priority : priorityOrder)
	{
	AlarmStateEnum alarmState = AlarmStateEnum::kNormal;
	EndOfServiceEnum endOfServiceState = EndOfServiceEnum::kNormal;
	bool active = false;
	bool success = false;

	switch (priority)
	{
	case ExpressedStateEnum::kSmokeAlarm:
	success = GetSmokeState(endpointId, alarmState);
	break;
	case ExpressedStateEnum::kCOAlarm:
	success = GetCOState(endpointId, alarmState);
	break;
	case ExpressedStateEnum::kBatteryAlert:
	success = GetBatteryAlert(endpointId, alarmState);
	break;
	case ExpressedStateEnum::kTesting:
	success = GetTestInProgress(endpointId, active);
	break;
	case ExpressedStateEnum::kHardwareFault:
	success = GetHardwareFaultAlert(endpointId, active);
	break;
	case ExpressedStateEnum::kEndOfService:
	success = GetEndOfServiceAlert(endpointId, endOfServiceState);
	break;
	case ExpressedStateEnum::kInterconnectSmoke:
	success = GetInterconnectSmokeAlarm(endpointId, alarmState);
	break;
	case ExpressedStateEnum::kInterconnectCO:
	success = GetInterconnectCOAlarm(endpointId, alarmState);
	break;
	default:
	break;
	}

	if (success && ((alarmState != AlarmStateEnum::kNormal) \|\| (endOfServiceState != EndOfServiceEnum::kNormal) \|\| active))
	{
	SetExpressedState(endpointId, priority);
	return;
	}
	}

	SetExpressedState(endpointId, ExpressedStateEnum::kNormal);
	}

	bool SmokeCoAlarmServer::RequestSelfTest(EndpointId endpointId)
	{
	ExpressedStateEnum expressedState;
	VerifyOrReturnValue(GetExpressedState(endpointId, expressedState), false);

	// If the value is busy then return busy
	if (expressedState == ExpressedStateEnum::kSmokeAlarm \|\| expressedState == ExpressedStateEnum::kCOAlarm \|\|
	expressedState == ExpressedStateEnum::kTesting \|\| expressedState == ExpressedStateEnum::kInterconnectSmoke \|\|
	expressedState == ExpressedStateEnum::kInterconnectCO)
	{
	return false;
	}

	VerifyOrReturnValue(SetTestInProgress(endpointId, true), false);
	SetExpressedState(endpointId, ExpressedStateEnum::kTesting);

	emberAfPluginSmokeCoAlarmSelfTestRequestCommand(endpointId);

	return true;
	}

	bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState)
	{
	AlarmStateEnum alarmState;
	VerifyOrReturnValue(GetAttribute(endpointId, SmokeState::Id, SmokeState::Get, alarmState), false);
	VerifyOrReturnValue(alarmState != newSmokeState, true);

	VerifyOrReturnValue(SetAttribute(endpointId, SmokeState::Id, SmokeState::Set, newSmokeState), false);
	if (newSmokeState == AlarmStateEnum::kWarning \|\| newSmokeState == AlarmStateEnum::kCritical)
	{
	Events::SmokeAlarm::Type event{ newSmokeState };
	SendEvent(endpointId, event);
	}

	if (newSmokeState == AlarmStateEnum::kCritical)
	{
	SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetCOState(EndpointId endpointId, AlarmStateEnum newCOState)
	{
	AlarmStateEnum alarmState;
	VerifyOrReturnValue(GetAttribute(endpointId, COState::Id, COState::Get, alarmState), false);
	VerifyOrReturnValue(alarmState != newCOState, true);

	VerifyOrReturnValue(SetAttribute(endpointId, COState::Id, COState::Set, newCOState), false);
	if (newCOState == AlarmStateEnum::kWarning \|\| newCOState == AlarmStateEnum::kCritical)
	{
	Events::COAlarm::Type event{ newCOState };
	SendEvent(endpointId, event);
	}

	if (newCOState == AlarmStateEnum::kCritical)
	{
	SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetBatteryAlert(EndpointId endpointId, AlarmStateEnum newBatteryAlert)
	{
	AlarmStateEnum alarmState;
	VerifyOrReturnValue(GetAttribute(endpointId, BatteryAlert::Id, BatteryAlert::Get, alarmState), false);
	VerifyOrReturnValue(alarmState != newBatteryAlert, true);

	VerifyOrReturnValue(SetAttribute(endpointId, BatteryAlert::Id, BatteryAlert::Set, newBatteryAlert), false);
	if (newBatteryAlert == AlarmStateEnum::kWarning \|\| newBatteryAlert == AlarmStateEnum::kCritical)
	{
	Events::LowBattery::Type event{ newBatteryAlert };
	SendEvent(endpointId, event);
	}

	if (newBatteryAlert == AlarmStateEnum::kCritical)
	{
	SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetDeviceMuted(EndpointId endpointId, MuteStateEnum newDeviceMuted)
	{
	MuteStateEnum deviceMuted;
	VerifyOrReturnValue(GetAttribute(endpointId, DeviceMuted::Id, DeviceMuted::Get, deviceMuted), false);
	VerifyOrReturnValue(deviceMuted != newDeviceMuted, true);

	if (newDeviceMuted == MuteStateEnum::kMuted)
	{
	AlarmStateEnum alarmState;

	// If the attribute has been read and the attribute is Critical, return false

	bool success = GetSmokeState(endpointId, alarmState);
	VerifyOrReturnValue(!success \|\| alarmState != AlarmStateEnum::kCritical, false);

	success = GetCOState(endpointId, alarmState);
	VerifyOrReturnValue(!success \|\| alarmState != AlarmStateEnum::kCritical, false);

	success = GetBatteryAlert(endpointId, alarmState);
	VerifyOrReturnValue(!success \|\| alarmState != AlarmStateEnum::kCritical, false);

	success = GetInterconnectSmokeAlarm(endpointId, alarmState);
	VerifyOrReturnValue(!success \|\| alarmState != AlarmStateEnum::kCritical, false);

	success = GetInterconnectCOAlarm(endpointId, alarmState);
	VerifyOrReturnValue(!success \|\| alarmState != AlarmStateEnum::kCritical, false);
	}

	VerifyOrReturnValue(SetAttribute(endpointId, DeviceMuted::Id, DeviceMuted::Set, newDeviceMuted), false);
	if (newDeviceMuted == MuteStateEnum::kMuted)
	{
	Events::AlarmMuted::Type event{};
	SendEvent(endpointId, event);
	}
	else if (newDeviceMuted == MuteStateEnum::kNotMuted)
	{
	Events::MuteEnded::Type event{};
	SendEvent(endpointId, event);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetTestInProgress(EndpointId endpointId, bool newTestInProgress)
	{
	bool active;
	VerifyOrReturnValue(GetAttribute(endpointId, TestInProgress::Id, TestInProgress::Get, active), false);
	VerifyOrReturnValue(active != newTestInProgress, true);

	VerifyOrReturnValue(SetAttribute(endpointId, TestInProgress::Id, TestInProgress::Set, newTestInProgress), false);
	if (!newTestInProgress)
	{
	Events::SelfTestComplete::Type event{};
	SendEvent(endpointId, event);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetHardwareFaultAlert(EndpointId endpointId, bool newHardwareFaultAlert)
	{
	bool active;
	VerifyOrReturnValue(GetAttribute(endpointId, HardwareFaultAlert::Id, HardwareFaultAlert::Get, active), false);
	VerifyOrReturnValue(active != newHardwareFaultAlert, true);

	VerifyOrReturnValue(SetAttribute(endpointId, HardwareFaultAlert::Id, HardwareFaultAlert::Set, newHardwareFaultAlert), false);
	if (newHardwareFaultAlert)
	{
	Events::HardwareFault::Type event{};
	SendEvent(endpointId, event);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetEndOfServiceAlert(EndpointId endpointId, EndOfServiceEnum newEndOfServiceAlert)
	{
	EndOfServiceEnum endOfServiceState;
	VerifyOrReturnValue(GetAttribute(endpointId, EndOfServiceAlert::Id, EndOfServiceAlert::Get, endOfServiceState), false);
	VerifyOrReturnValue(endOfServiceState != newEndOfServiceAlert, true);

	VerifyOrReturnValue(SetAttribute(endpointId, EndOfServiceAlert::Id, EndOfServiceAlert::Set, newEndOfServiceAlert), false);
	if (newEndOfServiceAlert == EndOfServiceEnum::kExpired)
	{
	Events::EndOfService::Type event{};
	SendEvent(endpointId, event);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetInterconnectSmokeAlarm(EndpointId endpointId, AlarmStateEnum newInterconnectSmokeAlarm)
	{
	AlarmStateEnum alarmState;
	VerifyOrReturnValue(GetAttribute(endpointId, InterconnectSmokeAlarm::Id, InterconnectSmokeAlarm::Get, alarmState), false);
	VerifyOrReturnValue(alarmState != newInterconnectSmokeAlarm, true);

	VerifyOrReturnValue(
	SetAttribute(endpointId, InterconnectSmokeAlarm::Id, InterconnectSmokeAlarm::Set, newInterconnectSmokeAlarm), false);
	if (newInterconnectSmokeAlarm == AlarmStateEnum::kWarning \|\| newInterconnectSmokeAlarm == AlarmStateEnum::kCritical)
	{
	Events::InterconnectSmokeAlarm::Type event{ newInterconnectSmokeAlarm };
	SendEvent(endpointId, event);
	}

	if (newInterconnectSmokeAlarm == AlarmStateEnum::kCritical)
	{
	SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetInterconnectCOAlarm(EndpointId endpointId, AlarmStateEnum newInterconnectCOAlarm)
	{
	AlarmStateEnum alarmState;
	VerifyOrReturnValue(GetAttribute(endpointId, InterconnectCOAlarm::Id, InterconnectCOAlarm::Get, alarmState), false);
	VerifyOrReturnValue(alarmState != newInterconnectCOAlarm, true);

	VerifyOrReturnValue(SetAttribute(endpointId, InterconnectCOAlarm::Id, InterconnectCOAlarm::Set, newInterconnectCOAlarm), false);
	if (newInterconnectCOAlarm == AlarmStateEnum::kWarning \|\| newInterconnectCOAlarm == AlarmStateEnum::kCritical)
	{
	Events::InterconnectCOAlarm::Type event{ newInterconnectCOAlarm };
	SendEvent(endpointId, event);
	}

	if (newInterconnectCOAlarm == AlarmStateEnum::kCritical)
	{
	SetDeviceMuted(endpointId, MuteStateEnum::kNotMuted);
	}

	return true;
	}

	bool SmokeCoAlarmServer::SetContaminationState(EndpointId endpointId, ContaminationStateEnum newContaminationState)
	{
	ContaminationStateEnum contaminationState;
	VerifyOrReturnValue(GetAttribute(endpointId, ContaminationState::Id, ContaminationState::Get, contaminationState), false);
	VerifyOrReturnValue(contaminationState != newContaminationState, true);

	VerifyOrReturnValue(SetAttribute(endpointId, ContaminationState::Id, ContaminationState::Set, newContaminationState), false);

	return true;
	}

	bool SmokeCoAlarmServer::SetSmokeSensitivityLevel(EndpointId endpointId, SensitivityEnum newSmokeSensitivityLevel)
	{
	SensitivityEnum sensitivity;
	VerifyOrReturnValue(GetAttribute(endpointId, SmokeSensitivityLevel::Id, SmokeSensitivityLevel::Get, sensitivity), false);
	VerifyOrReturnValue(sensitivity != newSmokeSensitivityLevel, true);

	VerifyOrReturnValue(SetAttribute(endpointId, SmokeSensitivityLevel::Id, SmokeSensitivityLevel::Set, newSmokeSensitivityLevel),
	false);

	return true;
	}

	bool SmokeCoAlarmServer::GetExpressedState(chip ::EndpointId endpointId, ExpressedStateEnum & expressedState)
	{
	return GetAttribute(endpointId, ExpressedState::Id, ExpressedState::Get, expressedState);
	}

	bool SmokeCoAlarmServer::GetSmokeState(EndpointId endpointId, AlarmStateEnum & smokeState)
	{
	return GetAttribute(endpointId, SmokeState::Id, SmokeState::Get, smokeState);
	}

	bool SmokeCoAlarmServer::GetCOState(EndpointId endpointId, AlarmStateEnum & coState)
	{
	return GetAttribute(endpointId, COState::Id, COState::Get, coState);
	}

	bool SmokeCoAlarmServer::GetBatteryAlert(EndpointId endpointId, AlarmStateEnum & batteryAlert)
	{
	return GetAttribute(endpointId, BatteryAlert::Id, BatteryAlert::Get, batteryAlert);
	}

	bool SmokeCoAlarmServer::GetDeviceMuted(EndpointId endpointId, MuteStateEnum & deviceMuted)
	{
	return GetAttribute(endpointId, DeviceMuted::Id, DeviceMuted::Get, deviceMuted);
	}

	bool SmokeCoAlarmServer::GetTestInProgress(EndpointId endpointId, bool & testInProgress)
	{
	return GetAttribute(endpointId, TestInProgress::Id, TestInProgress::Get, testInProgress);
	}

	bool SmokeCoAlarmServer::GetHardwareFaultAlert(EndpointId endpointId, bool & hardwareFaultAlert)
	{
	return GetAttribute(endpointId, HardwareFaultAlert::Id, HardwareFaultAlert::Get, hardwareFaultAlert);
	}

	bool SmokeCoAlarmServer::GetEndOfServiceAlert(EndpointId endpointId, EndOfServiceEnum & endOfServiceAlert)
	{
	return GetAttribute(endpointId, EndOfServiceAlert::Id, EndOfServiceAlert::Get, endOfServiceAlert);
	}

	bool SmokeCoAlarmServer::GetInterconnectSmokeAlarm(EndpointId endpointId, AlarmStateEnum & interconnectSmokeAlarm)
	{
	return GetAttribute(endpointId, InterconnectSmokeAlarm::Id, InterconnectSmokeAlarm::Get, interconnectSmokeAlarm);
	}

	bool SmokeCoAlarmServer::GetInterconnectCOAlarm(EndpointId endpointId, AlarmStateEnum & interconnectCOAlarm)
	{
	return GetAttribute(endpointId, InterconnectCOAlarm::Id, InterconnectCOAlarm::Get, interconnectCOAlarm);
	}

	bool SmokeCoAlarmServer::GetContaminationState(EndpointId endpointId, ContaminationStateEnum & contaminationState)
	{
	return GetAttribute(endpointId, ContaminationState::Id, ContaminationState::Get, contaminationState);
	}

	bool SmokeCoAlarmServer::GetSmokeSensitivityLevel(EndpointId endpointId, SensitivityEnum & smokeSensitivityLevel)
	{
	return GetAttribute(endpointId, SmokeSensitivityLevel::Id, SmokeSensitivityLevel::Get, smokeSensitivityLevel);
	}

	bool SmokeCoAlarmServer::GetExpiryDate(EndpointId endpointId, uint32_t & expiryDate)
	{
	return GetAttribute(endpointId, ExpiryDate::Id, ExpiryDate::Get, expiryDate);
	}

	chip::BitFlags<Feature> SmokeCoAlarmServer::GetFeatures(EndpointId endpointId)
	{
	chip::BitFlags<Feature> featureMap;
	if (!GetAttribute(endpointId, FeatureMap::Id, FeatureMap::Get, *featureMap.RawStorage()))
	{
	ChipLogError(Zcl, "Unable to get the Smoke CO Alarm feature map: attribute read error");
	featureMap.ClearAll();
	}
	return featureMap;
	}

	/**********************************************************
	* SmokeCoAlarmServer private methods
	*********************************************************/

	void SmokeCoAlarmServer::SetExpressedState(EndpointId endpointId, ExpressedStateEnum newExpressedState)
	{
	ExpressedStateEnum expressedState;
	VerifyOrReturn(GetAttribute(endpointId, ExpressedState::Id, ExpressedState::Get, expressedState));
	VerifyOrReturn(expressedState != newExpressedState);

	VerifyOrReturn(SetAttribute(endpointId, ExpressedState::Id, ExpressedState::Set, newExpressedState));
	if (newExpressedState == ExpressedStateEnum::kNormal)
	{
	Events::AllClear::Type event{};
	SendEvent(endpointId, event);
	}
	}

	void SmokeCoAlarmServer::HandleRemoteSelfTestRequest(CommandHandler * commandObj, const ConcreteCommandPath & commandPath)
	{
	EndpointId endpointId = commandPath.mEndpointId;

	ExpressedStateEnum expressedState;
	VerifyOrReturn(GetExpressedState(endpointId, expressedState), commandObj->AddStatus(commandPath, Status::Failure));

	// If the value is busy then return busy
	if (expressedState == ExpressedStateEnum::kSmokeAlarm \|\| expressedState == ExpressedStateEnum::kCOAlarm \|\|
	expressedState == ExpressedStateEnum::kTesting \|\| expressedState == ExpressedStateEnum::kInterconnectSmoke \|\|
	expressedState == ExpressedStateEnum::kInterconnectCO)
	{
	commandObj->AddStatus(commandPath, Status::Busy);
	return;
	}

	VerifyOrReturn(SetTestInProgress(endpointId, true), commandObj->AddStatus(commandPath, Status::Failure));
	SetExpressedState(endpointId, ExpressedStateEnum::kTesting);

	emberAfPluginSmokeCoAlarmSelfTestRequestCommand(endpointId);

	commandObj->AddStatus(commandPath, Status::Success);
	}

	template <typename T>
	void SmokeCoAlarmServer::SendEvent(EndpointId endpointId, T & event)
	{
	EventNumber eventNumber;
	auto err = LogEvent(event, endpointId, eventNumber);

	if (CHIP_NO_ERROR != err)
	{
	ChipLogError(Zcl, "Failed to log event: err=%" CHIP_ERROR_FORMAT ", event_id=" ChipLogFormatMEI, err.Format(),
	ChipLogValueMEI(event.GetEventId()));
	}
	}

	template <typename T>
	bool SmokeCoAlarmServer::GetAttribute(EndpointId endpointId, AttributeId attributeId,
	Status (getFn)(EndpointId endpointId, T value), T & value) const
	{
	Status status = getFn(endpointId, &value);
	bool success = (Status::Success == status);
	bool unsupportedStatus = (Status::UnsupportedAttribute == status);

	if (unsupportedStatus)
	{
	ChipLogProgress(Zcl, "Read unsupported SmokeCOAlarm attribute: attribute=" ChipLogFormatMEI, ChipLogValueMEI(attributeId));
	}
	else if (!success)
	{
	ChipLogError(Zcl, "Failed to read SmokeCOAlarm attribute: attribute=" ChipLogFormatMEI ", status=0x%x",
	ChipLogValueMEI(attributeId), to_underlying(status));
	}
	return success;
	}

	template <typename T>
	bool SmokeCoAlarmServer::SetAttribute(EndpointId endpointId, AttributeId attributeId,
	Status (*setFn)(EndpointId endpointId, T value), T value)
	{
	Status status = setFn(endpointId, value);
	bool success = (Status::Success == status);

	if (!success)
	{
	ChipLogError(Zcl, "Failed to write SmokeCOAlarm attribute: attribute=" ChipLogFormatMEI ", status=0x%x",
	ChipLogValueMEI(attributeId), to_underlying(status));
	}
	return success;
	}

	// =============================================================================
	// Cluster commands callbacks
	// =============================================================================

	bool emberAfSmokeCoAlarmClusterSelfTestRequestCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
	const Commands::SelfTestRequest::DecodableType & commandData)
	{
	SmokeCoAlarmServer::Instance().HandleRemoteSelfTestRequest(commandObj, commandPath);
	return true;
	}

	void MatterSmokeCoAlarmPluginServerInitCallback() {}