EFR32 lock event generation using matter shell (#23248)

* EFR32 lock event generation using matter shell

code review comment cleanup

* code review comments

examples/lock-app/efr32/BUILD.gn

@@ -187,6 +187,10 @@ efr32_executable("lock_app") {
     sources += [ "${examples_plat_dir}/uart.cpp" ]
   }
 
+  if (chip_build_libshell) {
+    sources += [ "src/EventHandlerLibShell.cpp" ]
+  }
+
   deps = [
     ":sdk",
     "${chip_root}/examples/lock-app/lock-common",

examples/lock-app/efr32/include/AppTask.h

@@ -49,6 +49,9 @@
 #define APP_ERROR_START_TIMER_FAILED CHIP_APPLICATION_ERROR(0x05)
 #define APP_ERROR_STOP_TIMER_FAILED CHIP_APPLICATION_ERROR(0x06)
 #define APP_ERROR_ALLOCATION_FAILED CHIP_APPLICATION_ERROR(0x07)
+#if defined(ENABLE_CHIP_SHELL)
+#define APP_ERROR_TOO_MANY_SHELL_ARGUMENTS CHIP_APPLICATION_ERROR(0x08)
+#endif // ENABLE_CHIP_SHELL
 
 /**********************************************************
  * AppTask Declaration

examples/lock-app/efr32/include/EventHandlerLibShell.h

@@ -0,0 +1,40 @@
+/*
+ *
+ *    Copyright (c) 2020 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.
+ */
+#pragma once
+
+#include <app/clusters/door-lock-server/door-lock-server.h>
+
+class EventData
+{
+public:
+    chip::EventId eventId;
+};
+
+class AlarmEventData : public EventData
+{
+public:
+    DlAlarmCode alarmCode;
+};
+
+class DoorStateEventData : public EventData
+{
+public:
+    DlDoorState doorState;
+};
+
+CHIP_ERROR RegisterLockEvents();
+void EventWorkerFunction(intptr_t context);

examples/lock-app/efr32/src/AppTask.cpp

@@ -20,6 +20,9 @@
 #include "AppTask.h"
 #include "AppConfig.h"
 #include "AppEvent.h"
+#if defined(ENABLE_CHIP_SHELL)
+#include "EventHandlerLibShell.h"
+#endif // ENABLE_CHIP_SHELL
 
 #ifdef ENABLE_WSTK_LEDS
 #include "LEDWidget.h"
@@ -161,6 +164,15 @@ CHIP_ERROR AppTask::Init()
         appError(err);
     }
 
+#if defined(ENABLE_CHIP_SHELL)
+    err = RegisterLockEvents();
+    if (err != CHIP_NO_ERROR)
+    {
+        EFR32_LOG("RegisterLockEvents() failed");
+        appError(err);
+    }
+#endif // ENABLE_CHIP_SHELL
+
     // Initial lock state
     chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> state;
     chip::EndpointId endpointId{ 1 };

examples/lock-app/efr32/src/EventHandlerLibShell.cpp

@@ -0,0 +1,211 @@
+/*
+ *
+ *    Copyright (c) 2020 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 "EventHandlerLibShell.h"
+#include "AppTask.h"
+#include "lib/shell/Engine.h"
+#include "lib/shell/commands/Help.h"
+
+#include "app/server/Server.h"
+#include "platform/CHIPDeviceLayer.h"
+#include <lib/support/CodeUtils.h>
+
+constexpr uint8_t lockEndpoint = 1;
+
+using namespace chip;
+using namespace chip::app;
+using namespace Clusters::DoorLock;
+using Shell::Engine;
+using Shell::shell_command_t;
+using Shell::streamer_get;
+using Shell::streamer_printf;
+
+Engine sShellDoorlockSubCommands;
+Engine sShellDoorlockEventSubCommands;
+Engine sShellDoorlockEventAlarmSubCommands;
+Engine sShellDoorlockEventDoorStateSubCommands;
+
+/********************************************************
+ * Doorlock shell functions
+ *********************************************************/
+
+CHIP_ERROR DoorlockHelpHandler(int argc, char ** argv)
+{
+    sShellDoorlockSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DoorlockCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return DoorlockHelpHandler(argc, argv);
+    }
+
+    return sShellDoorlockSubCommands.ExecCommand(argc, argv);
+}
+
+/********************************************************
+ * Event shell functions
+ *********************************************************/
+
+CHIP_ERROR EventHelpHandler(int argc, char ** argv)
+{
+    sShellDoorlockEventSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR EventDoorlockCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return EventHelpHandler(argc, argv);
+    }
+
+    return sShellDoorlockEventSubCommands.ExecCommand(argc, argv);
+}
+
+/********************************************************
+ * Alarm shell functions
+ *********************************************************/
+
+CHIP_ERROR AlarmHelpHandler(int argc, char ** argv)
+{
+    sShellDoorlockEventAlarmSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR AlarmEventHandler(int argc, char ** argv)
+{
+
+    if (argc == 0)
+    {
+        return AlarmHelpHandler(argc, argv);
+    }
+    if (argc >= 2)
+    {
+        ChipLogError(Zcl, "Too many arguments provided to function %s, line %d", __func__, __LINE__);
+        return APP_ERROR_TOO_MANY_SHELL_ARGUMENTS;
+    }
+
+    AlarmEventData * data = Platform::New<AlarmEventData>();
+    data->eventId         = Events::DoorLockAlarm::Id;
+    data->alarmCode       = static_cast<DlAlarmCode>(atoi(argv[0]));
+
+    DeviceLayer::PlatformMgr().ScheduleWork(EventWorkerFunction, reinterpret_cast<intptr_t>(data));
+
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Door state shell functions
+ *********************************************************/
+
+CHIP_ERROR DoorStateHelpHandler(int argc, char ** argv)
+{
+    sShellDoorlockEventDoorStateSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DoorStateEventHandler(int argc, char ** argv)
+{
+
+    if (argc == 0)
+    {
+        return DoorStateHelpHandler(argc, argv);
+    }
+    if (argc >= 2)
+    {
+        ChipLogError(Zcl, "Too many arguments provided to function %s, line %d", __func__, __LINE__);
+        return APP_ERROR_TOO_MANY_SHELL_ARGUMENTS;
+    }
+
+    DoorStateEventData * data = Platform::New<DoorStateEventData>();
+    data->eventId             = Events::DoorStateChange::Id;
+    data->doorState           = static_cast<DlDoorState>(atoi(argv[0]));
+
+    DeviceLayer::PlatformMgr().ScheduleWork(EventWorkerFunction, reinterpret_cast<intptr_t>(data));
+
+    return CHIP_NO_ERROR;
+}
+
+/**
+ * @brief configures lock matter shell
+ *
+ */
+
+CHIP_ERROR RegisterLockEvents()
+{
+    static const shell_command_t sDoorlockSubCommands[] = { { &DoorlockHelpHandler, "help", "Usage: doorlock <subcommand>" },
+                                                            { &EventDoorlockCommandHandler, "event",
+                                                              " Usage: doorlock event <subcommand>" } };
+
+    static const shell_command_t sDoorlockEventSubCommands[] = {
+        { &EventHelpHandler, "help", "Usage : doorlock event <subcommand>" },
+        { &AlarmEventHandler, "lock-alarm", "Sends lock alarm event to lock app" },
+        { &DoorStateEventHandler, "door-state-change", "Sends door state change event to lock app" }
+    };
+
+    static const shell_command_t sDoorlockEventAlarmSubCommands[] = { { &AlarmHelpHandler, "help",
+                                                                        "Usage : doorlock event lock-alarm AlarmCode" } };
+
+    static const shell_command_t sDoorlockEventDoorStateSubCommands[] = {
+        { &DoorStateHelpHandler, "help", "Usage : doorlock event door-state-change DoorState" }
+    };
+
+    static const shell_command_t sDoorLockCommand = { &DoorlockCommandHandler, "doorlock",
+                                                      "doorlock commands. Usage: doorlock <subcommand>" };
+
+    sShellDoorlockEventAlarmSubCommands.RegisterCommands(sDoorlockEventAlarmSubCommands, ArraySize(sDoorlockEventAlarmSubCommands));
+
+    sShellDoorlockEventDoorStateSubCommands.RegisterCommands(sDoorlockEventDoorStateSubCommands,
+                                                             ArraySize(sDoorlockEventDoorStateSubCommands));
+
+    sShellDoorlockEventSubCommands.RegisterCommands(sDoorlockEventSubCommands, ArraySize(sDoorlockEventSubCommands));
+    sShellDoorlockSubCommands.RegisterCommands(sDoorlockSubCommands, ArraySize(sDoorlockSubCommands));
+
+    Engine::Root().RegisterCommands(&sDoorLockCommand, 1);
+
+    return CHIP_NO_ERROR;
+}
+
+void EventWorkerFunction(intptr_t context)
+{
+    VerifyOrReturn(context != 0, ChipLogError(NotSpecified, "EventWorkerFunction - Invalid work data"));
+
+    EventData * data = reinterpret_cast<EventData *>(context);
+
+    switch (data->eventId)
+    {
+    case Events::DoorLockAlarm::Id: {
+        AlarmEventData * alarmData = reinterpret_cast<AlarmEventData *>(context);
+        DoorLockServer::Instance().SendLockAlarmEvent(lockEndpoint, alarmData->alarmCode);
+        break;
+    }
+
+    case Events::DoorStateChange::Id: {
+        DoorStateEventData * doorStateData = reinterpret_cast<DoorStateEventData *>(context);
+        DoorLockServer::Instance().SetDoorState(lockEndpoint, doorStateData->doorState);
+        break;
+    }
+
+    default: {
+        ChipLogError(Zcl, "Invalid Event Id %s, line %d", __func__, __LINE__);
+        break;
+    }
+    }
+}