Add support for SmokeCO TC's in chip-all-clusters-app (#28548)

* Add support for SmokeCO TC's in chip-all-clusters-app

Address Issues:
Fixes Cert blocker issues : 28193, 27747, 27746, 27742, 27731

* Improve SmokeCO TC support in all-clusters-app

* Move priority order to server

* Revision per review comments

* Make smco-test-event-trigger public

* Add deps to tizen

* Revision per review comments

* Add LogErrorOnFailure

* Update src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Revert "Add LogErrorOnFailure"

This reverts commit 25c27da.

* Add ChipLogError

* Remove redundant code

---------

Co-authored-by: Chris Beach <chrisbeach59@gmail.com>
Co-authored-by: Hare <renilr0@outlook.com>
Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp

@@ -15,9 +15,173 @@
  *    limitations under the License.
  */
 
-#include <lib/core/DataModelTypes.h>
+#include <app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h>
+#include <app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h>
 
-bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(chip::EndpointId endpointId)
+#include <platform/CHIPDeviceLayer.h>
+
+using namespace chip;
+using namespace chip::app::Clusters::SmokeCoAlarm;
+using namespace chip::DeviceLayer;
+
+namespace {
+
+constexpr const uint16_t kSelfTestingTimeoutSec = 10;
+
+} // namespace
+
+static std::array<ExpressedStateEnum, SmokeCoAlarmServer::kPriorityOrderLength> sPriorityOrder = {
+    ExpressedStateEnum::kSmokeAlarm,     ExpressedStateEnum::kInterconnectSmoke, ExpressedStateEnum::kCOAlarm,
+    ExpressedStateEnum::kInterconnectCO, ExpressedStateEnum::kHardwareFault,     ExpressedStateEnum::kTesting,
+    ExpressedStateEnum::kEndOfService,   ExpressedStateEnum::kBatteryAlert
+};
+
+void EndSelfTestingEventHandler(System::Layer * systemLayer, void * appState)
+{
+    SmokeCoAlarmServer::Instance().SetTestInProgress(1, false);
+    SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+
+    ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test complete");
+}
+
+bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(EndpointId endpointId)
 {
+    SmokeCoAlarmServer::Instance().SetTestInProgress(1, true);
+
+    ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test running");
+
+    DeviceLayer::SystemLayer().StartTimer(System::Clock::Seconds32(kSelfTestingTimeoutSec), EndSelfTestingEventHandler, nullptr);
+
+    return true;
+}
+
+bool HandleSmokeCOTestEventTrigger(uint64_t eventTrigger)
+{
+    SmokeCOTrigger trigger = static_cast<SmokeCOTrigger>(eventTrigger);
+
+    switch (trigger)
+    {
+    case SmokeCOTrigger::kForceSmokeCritical:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke (critical)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kCritical), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceSmokeWarning:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke (warning)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kWarning), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceSmokeInterconnect:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke interconnect (warning)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, AlarmStateEnum::kWarning), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceCOCritical:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (critical)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kCritical), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceCOWarning:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (warning)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kWarning), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceCOInterconnect:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (warning)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, AlarmStateEnum::kWarning), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceSmokeContaminationHigh:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (critical)");
+        SmokeCoAlarmServer::Instance().SetContaminationState(1, ContaminationStateEnum::kCritical);
+        break;
+    case SmokeCOTrigger::kForceSmokeContaminationLow:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (warning)");
+        SmokeCoAlarmServer::Instance().SetContaminationState(1, ContaminationStateEnum::kLow);
+        break;
+    case SmokeCOTrigger::kForceSmokeSensitivityHigh:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke sensistivity (high)");
+        SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SensitivityEnum::kHigh);
+        break;
+    case SmokeCOTrigger::kForceSmokeSensitivityLow:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke sensitivity (low)");
+        SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SensitivityEnum::kLow);
+        break;
+    case SmokeCOTrigger::kForceMalfunction:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force malfunction");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, true), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceLowBatteryWarning:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force low battery (warning)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kWarning), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceLowBatteryCritical:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force low battery (critical)");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kCritical), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceEndOfLife:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force end-of-life");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, EndOfServiceEnum::kExpired), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kForceSilence:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force silence");
+        SmokeCoAlarmServer::Instance().SetDeviceMuted(1, MuteStateEnum::kMuted);
+        break;
+    case SmokeCOTrigger::kClearSmoke:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear smoke");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kNormal), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearCO:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear CO");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kNormal), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearSmokeInterconnect:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear smoke interconnect");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, AlarmStateEnum::kNormal), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearCOInterconnect:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear CO interconnect");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, AlarmStateEnum::kNormal), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearMalfunction:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear malfunction");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, false), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearEndOfLife:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear end-of-life");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, EndOfServiceEnum::kNormal), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearSilence:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear silence");
+        SmokeCoAlarmServer::Instance().SetDeviceMuted(1, MuteStateEnum::kNotMuted);
+        break;
+    case SmokeCOTrigger::kClearBatteryLevelLow:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear low battery");
+        VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kNormal), true);
+        SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder);
+        break;
+    case SmokeCOTrigger::kClearContamination:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force SmokeContamination (warning)");
+        SmokeCoAlarmServer::Instance().SetContaminationState(1, ContaminationStateEnum::kNormal);
+        break;
+    case SmokeCOTrigger::kClearSensitivity:
+        ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear Smoke Sensitivity");
+        SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SensitivityEnum::kStandard);
+        break;
+    default:
+
+        return false;
+    }
+
     return true;
 }

examples/all-clusters-app/linux/args.gni

@@ -27,3 +27,4 @@ chip_project_config_include_dirs += [ "${chip_root}/config/standalone" ]
 matter_enable_tracing_support = true
 matter_log_json_payload_decode_full = true
 matter_log_json_payload_hex = true
+chip_enable_smoke_co_trigger = true

examples/all-clusters-app/tizen/BUILD.gn

@@ -34,6 +34,7 @@ source_set("chip-all-clusters-common") {
 
   deps = [
     "${chip_root}/examples/all-clusters-app/all-clusters-common",
+    "${chip_root}/examples/platform/tizen:app-main",
     "${chip_root}/src/lib/shell:shell_core",
   ]
 

examples/all-clusters-minimal-app/tizen/BUILD.gn

@@ -31,6 +31,7 @@ source_set("chip-all-clusters-common") {
 
   deps = [
     "${chip_root}/examples/all-clusters-minimal-app/all-clusters-common",
+    "${chip_root}/examples/platform/tizen:app-main",
     "${chip_root}/src/lib/shell:shell_core",
   ]
 

examples/platform/linux/AppMain.cpp

@@ -75,6 +75,9 @@
 #if CHIP_DEVICE_CONFIG_ENABLE_OTA_REQUESTOR
 #include <app/clusters/ota-requestor/OTATestEventTriggerDelegate.h>
 #endif
+#if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER
+#include <app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h>
+#endif
 #include <app/TestEventTriggerDelegate.h>
 
 #include <signal.h>
@@ -522,6 +525,12 @@ void ChipLinuxAppMainLoop(AppMainLoopImplementation * impl)
     static OTATestEventTriggerDelegate otaTestEventTriggerDelegate{ ByteSpan(
         LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey) };
     otherDelegate = &otaTestEventTriggerDelegate;
+#endif
+#if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER
+    static SmokeCOTestEventTriggerDelegate smokeCOTestEventTriggerDelegate{
+        ByteSpan(LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey), otherDelegate
+    };
+    otherDelegate = &smokeCOTestEventTriggerDelegate;
 #endif
     // For general testing of TestEventTrigger, we have a common "core" event trigger delegate.
     static SampleTestEventTriggerDelegate testEventTriggerDelegate;

examples/platform/linux/BUILD.gn

@@ -19,6 +19,10 @@ import("${chip_root}/src/lib/core/core.gni")
 import("${chip_root}/src/lib/lib.gni")
 import("${chip_root}/src/tracing/tracing_args.gni")
 
+declare_args() {
+  chip_enable_smoke_co_trigger = false
+}
+
 config("app-main-config") {
   include_dirs = [ "." ]
 }
@@ -29,6 +33,10 @@ source_set("ota-test-event-trigger") {
   ]
 }
 
+source_set("smco-test-event-trigger") {
+  sources = [ "${chip_root}/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h" ]
+}
+
 source_set("app-main") {
   defines = [ "ENABLE_TRACING=${matter_enable_tracing_support}" ]
   sources = [
@@ -51,6 +59,7 @@ source_set("app-main") {
   ]
 
   public_deps = [
+    ":smco-test-event-trigger",
     "${chip_root}/src/lib",
     "${chip_root}/src/platform/logging:force_stdio",
   ]
@@ -85,6 +94,10 @@ source_set("app-main") {
     ]
   }
 
+  if (chip_enable_smoke_co_trigger) {
+    defines += [ "CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER=1" ]
+  }
+
   public_configs = [ ":app-main-config" ]
 }
 

src/app/chip_data_model.gni

@@ -287,6 +287,13 @@ template("chip_data_model") {
           "${_app_root}/clusters/${cluster}/resource-monitoring-cluster-objects.cpp",
           "${_app_root}/clusters/${cluster}/resource-monitoring-cluster-objects.h",
         ]
+      } else if (cluster == "smoke-co-alarm-server") {
+        sources += [
+          "${_app_root}/clusters/${cluster}/${cluster}.cpp",
+          "${_app_root}/clusters/${cluster}/${cluster}.h",
+          "${_app_root}/clusters/${cluster}/SmokeCOTestEventTriggerDelegate.cpp",
+          "${_app_root}/clusters/${cluster}/SmokeCOTestEventTriggerDelegate.h",
+        ]
       } else {
         sources += [ "${_app_root}/clusters/${cluster}/${cluster}.cpp" ]
       }

src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp

@@ -0,0 +1,42 @@
+/*
+ *
+ *    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 "SmokeCOTestEventTriggerDelegate.h"
+
+using namespace chip::app::Clusters::SmokeCoAlarm;
+
+namespace chip {
+
+bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enableKey) const
+{
+    return !mEnableKey.empty() && mEnableKey.data_equal(enableKey);
+}
+
+CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger)
+{
+    if (HandleSmokeCOTestEventTrigger(eventTrigger))
+    {
+        return CHIP_NO_ERROR;
+    }
+    if (mOtherDelegate != nullptr)
+    {
+        return mOtherDelegate->HandleEventTrigger(eventTrigger);
+    }
+    return CHIP_ERROR_INVALID_ARGUMENT;
+}
+
+} // namespace chip