[NXP][examples][common] Update app task common code

New task base API:
- PostEventsProcessedAction - this will be called in the main loop,
after all events have been processed. An example of concrete action
is to animate some LEDs.
- PrintOnboardingInfo - the default implementation remains the same.
It can be overwritten by the concrete application task class.
- AppMatter_DisallowDeviceToSleep/AppMatter_AllowDeviceToSleep -
An application that uses low power mode should overwrite the API to
implement the allow/disallow entering low power mechanism.
Before taking the OT mutex, the device is disallowed to enter low power.
The device is allowed to enter low power after the OT mutex is released.

Other changes:
- The app event queue handle should be static such that the concrete
application task can initialize it during Start() call.
- The ticksToWait passed to xQueueReceived is used to specify
the maximum amount of time the task should block waiting for an event.
This can be modified according to the application needs, e.g. is needed
by an application that has LED animation.
- PostEvent should take into account ISR context when populating the event queue.
- PostEvent becomes a static method.
- Thread device type is specified by the following flag: CONFIG_THREAD_DEVICE_TYPE
This is set by default to kThreadDeviceType_Router.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>
(cherry picked from commit d88e78ea6c973eb736915110bb227ad3515eec98)

examples/platform/nxp/common/app_task/include/AppTaskBase.h

@@ -27,9 +27,8 @@
 #include <app/server/Server.h>
 #include <platform/NetworkCommissioning.h>
 
-namespace chip {
-namespace NXP {
-namespace App {
+namespace chip::NXP::App {
+
 class AppTaskBase
 {
 public:
@@ -79,6 +78,13 @@ class AppTaskBase
      */
     virtual void PostInitMatterStack(void) {};
 
+    /**
+     * \brief This function is called in AppTaskMain after all events are processed in current loop iteration.
+     *
+     * Example of usage: It can be used to animate some LEDs.
+     */
+    virtual void PostEventsProcessedAction() {}
+
     /**
      * \brief This function could be overridden in order to register features.
      *
@@ -97,6 +103,31 @@ class AppTaskBase
      */
     virtual void AppMatter_RegisterCustomCliCommands(void) {};
 
+    /**
+     * \brief Disallow entering low power mode.
+     *
+     * This function can be overridden in order to implement a specific disallow mechanism.
+     *
+     */
+    virtual void AppMatter_DisallowDeviceToSleep(void) {}
+
+    /**
+     * \brief Allow entering low power mode.
+     *
+     * This function can be overridden in order to implement a specific allow mechanism.
+     *
+     */
+    virtual void AppMatter_AllowDeviceToSleep(void) {}
+
+    /**
+     * \brief Print onboarding information.
+     *
+     * It can be overwritten by derived classes for custom information,
+     * such as setting the commissioning flow to kUserActionRequired.
+     *
+     */
+    virtual void PrintOnboardingInfo();
+
     /**
      * \brief This function could be overridden in order to dispatch event.
      *
@@ -142,6 +173,7 @@ class AppTaskBase
 
 private:
     inline static chip::CommonCaseDeviceServerInitParams initParams;
+
     /* Functions used by the public commisioning handlers */
     static void StartCommissioning(intptr_t arg);
     static void StopCommissioning(intptr_t arg);
@@ -154,6 +186,5 @@ class AppTaskBase
  * Applications can use this to gain access to features of the AppTaskBase.
  */
 extern AppTaskBase & GetAppTask();
-} // namespace App
-} // namespace NXP
-} // namespace chip
+
+} // namespace chip::NXP::App

examples/platform/nxp/common/app_task/include/AppTaskFreeRTOS.h

@@ -21,9 +21,8 @@
 
 #include "AppTaskBase.h"
 
-namespace chip {
-namespace NXP {
-namespace App {
+namespace chip::NXP::App {
+
 class AppTaskFreeRTOS : public AppTaskBase
 {
 public:
@@ -72,9 +71,20 @@ class AppTaskFreeRTOS : public AppTaskBase
      */
     virtual CHIP_ERROR AppMatter_Register(void) override;
 
+    /**
+     * \brief The app event queue handle should be static such that the concrete
+     * application task can initialize it during Start() call.
+     */
+    QueueHandle_t appEventQueue;
+
+    /**
+     * \brief This value is used when xQueueReceive is called to specify
+     * the maximum amount of time the task should block waiting for an event.
+     * This can be modified according to the application needs.
+     */
+    TickType_t ticksToWait;
+
 private:
     void DispatchEvent(const AppEvent & event);
 };
-} // namespace App
-} // namespace NXP
-} // namespace chip
+} // namespace chip::NXP::App

examples/platform/nxp/common/app_task/include/AppTaskZephyr.h

@@ -21,9 +21,8 @@
 
 #include "AppTaskBase.h"
 
-namespace chip {
-namespace NXP {
-namespace App {
+namespace chip::NXP::App {
+
 class AppTaskZephyr : public AppTaskBase
 {
 public:
@@ -65,6 +64,5 @@ class AppTaskZephyr : public AppTaskBase
 private:
     void DispatchEvent(const AppEvent & event);
 };
-} // namespace App
-} // namespace NXP
-} // namespace chip
+
+} // namespace chip::NXP::App

examples/platform/nxp/common/app_task/source/AppTaskBase.cpp

@@ -22,6 +22,7 @@
 #include "AppFactoryData.h"
 #include "CHIPDeviceManager.h"
 #include "CommonDeviceCallbacks.h"
+#include "OperationalKeystore.h"
 
 #include <app/server/Dnssd.h>
 #include <lib/dnssd/Advertiser.h>
@@ -67,6 +68,19 @@
 #include <lib/shell/commands/WiFi.h>
 #endif
 
+#ifdef SMOKE_CO_ALARM
+#include <app/TestEventTriggerDelegate.h>
+#include <app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerHandler.h>
+#endif
+
+/**
+ * \brief This flag can be set in build system to overwrite the default value.
+ *
+ */
+#ifndef CONFIG_THREAD_DEVICE_TYPE
+#define CONFIG_THREAD_DEVICE_TYPE kThreadDeviceType_Router
+#endif
+
 using namespace chip;
 using namespace chip::TLV;
 using namespace ::chip::Credentials;
@@ -90,12 +104,14 @@ static uint8_t sTestEventTriggerEnableKey[TestEventTriggerDelegate::kEnableKeyLe
 #if CONFIG_NET_L2_OPENTHREAD
 void LockOpenThreadTask(void)
 {
+    chip::NXP::App::GetAppTask().AppMatter_DisallowDeviceToSleep();
     chip::DeviceLayer::ThreadStackMgr().LockThreadStack();
 }
 
 void UnlockOpenThreadTask(void)
 {
     chip::DeviceLayer::ThreadStackMgr().UnlockThreadStack();
+    chip::NXP::App::GetAppTask().AppMatter_AllowDeviceToSleep();
 }
 #endif
 
@@ -107,7 +123,20 @@ void chip::NXP::App::AppTaskBase::InitServer(intptr_t arg)
     static OTATestEventTriggerDelegate testEventTriggerDelegate{ ByteSpan(sTestEventTriggerEnableKey) };
     initParams.testEventTriggerDelegate = &testEventTriggerDelegate;
 #endif
+
+#ifdef SMOKE_CO_ALARM
+    static SimpleTestEventTriggerDelegate sTestEventTriggerDelegate{};
+    static SmokeCOTestEventTriggerHandler sSmokeCOTestEventTriggerHandler{};
+    VerifyOrDie(sTestEventTriggerDelegate.Init(ByteSpan(sTestEventTriggerEnableKey)) == CHIP_NO_ERROR);
+    VerifyOrDie(sTestEventTriggerDelegate.AddHandler(&sSmokeCOTestEventTriggerHandler) == CHIP_NO_ERROR);
+    initParams.testEventTriggerDelegate = &sTestEventTriggerDelegate;
+#endif
+
+#if CHIP_CRYPTO_PLATFORM
+    initParams.operationalKeystore = chip::NXP::App::OperationalKeystore::GetInstance();
+#endif
     (void) initParams.InitializeStaticResourcesBeforeServerInit();
+
 #if CONFIG_NET_L2_OPENTHREAD
     // Init ZCL Data Model and start server
     chip::Inet::EndPointStateOpenThread::OpenThreadEndpointInitParam nativeParams;
@@ -118,8 +147,11 @@ void chip::NXP::App::AppTaskBase::InitServer(intptr_t arg)
 #endif
 
     VerifyOrDie((chip::Server::GetInstance().Init(initParams)) == CHIP_NO_ERROR);
-
-    gExampleDeviceInfoProvider.SetStorageDelegate(&Server::GetInstance().GetPersistentStorage());
+    auto * persistentStorage = &Server::GetInstance().GetPersistentStorage();
+#if CHIP_CRYPTO_PLATFORM
+    chip::NXP::App::OperationalKeystore::Init(persistentStorage);
+#endif
+    gExampleDeviceInfoProvider.SetStorageDelegate(persistentStorage);
     chip::DeviceLayer::SetDeviceInfoProvider(&gExampleDeviceInfoProvider);
 
     GetAppTask().PostInitMatterServerInstance();
@@ -188,7 +220,7 @@ CHIP_ERROR chip::NXP::App::AppTaskBase::Init()
         return err;
     }
 
-    err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_Router);
+    err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::CONFIG_THREAD_DEVICE_TYPE);
     if (err != CHIP_NO_ERROR)
     {
         return err;
@@ -229,11 +261,7 @@ CHIP_ERROR chip::NXP::App::AppTaskBase::Init()
     ConfigurationMgr().LogDeviceConfig();
 
     // QR code will be used with CHIP Tool
-#if CONFIG_NETWORK_LAYER_BLE
-    PrintOnboardingCodes(chip::RendezvousInformationFlag(chip::RendezvousInformationFlag::kBLE));
-#else
-    PrintOnboardingCodes(chip::RendezvousInformationFlag(chip::RendezvousInformationFlag::kOnNetwork));
-#endif /* CONFIG_NETWORK_LAYER_BLE */
+    PrintOnboardingInfo();
 
     /* Start a task to run the CHIP Device event loop. */
     err = PlatformMgr().StartEventLoopTask();
@@ -335,3 +363,12 @@ void chip::NXP::App::AppTaskBase::FactoryResetHandler(void)
     chip::Server::GetInstance().GenerateShutDownEvent();
     chip::Server::GetInstance().ScheduleFactoryReset();
 }
+
+void chip::NXP::App::AppTaskBase::PrintOnboardingInfo()
+{
+#if CONFIG_NETWORK_LAYER_BLE
+    PrintOnboardingCodes(chip::RendezvousInformationFlag(chip::RendezvousInformationFlag::kBLE));
+#else
+    PrintOnboardingCodes(chip::RendezvousInformationFlag(chip::RendezvousInformationFlag::kOnNetwork));
+#endif /* CONFIG_NETWORK_LAYER_BLE */
+}

examples/platform/nxp/common/app_task/source/AppTaskFreeRTOS.cpp

@@ -50,8 +50,6 @@
 #endif
 #define APP_EVENT_QUEUE_SIZE 10
 
-static QueueHandle_t sAppEventQueue;
-
 using namespace chip;
 using namespace chip::TLV;
 using namespace ::chip::Credentials;
@@ -71,6 +69,7 @@ chip::DeviceLayer::NetworkCommissioning::WiFiDriver * chip::NXP::App::AppTaskFre
 CHIP_ERROR chip::NXP::App::AppTaskFreeRTOS::AppMatter_Register()
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
+
     /* Register Matter CLI cmds */
 #ifdef ENABLE_CHIP_SHELL
     err = chip::NXP::App::GetAppCLI().Init();
@@ -92,14 +91,16 @@ CHIP_ERROR chip::NXP::App::AppTaskFreeRTOS::Start()
     CHIP_ERROR err = CHIP_NO_ERROR;
     TaskHandle_t taskHandle;
 
-    sAppEventQueue = xQueueCreate(APP_EVENT_QUEUE_SIZE, sizeof(AppEvent));
-    if (sAppEventQueue == NULL)
+    appEventQueue = xQueueCreate(APP_EVENT_QUEUE_SIZE, sizeof(AppEvent));
+    if (appEventQueue == NULL)
     {
         err = CHIP_ERROR_NO_MEMORY;
         ChipLogError(DeviceLayer, "Failed to allocate app event queue");
         assert(err == CHIP_NO_ERROR);
     }
 
+    ticksToWait = portMAX_DELAY;
+
     /* AppTaskMain function will loss actual object instance, give it as parameter */
     if (xTaskCreate(&AppTaskFreeRTOS::AppTaskMain, "AppTaskMain", APP_TASK_STACK_SIZE, this, APP_TASK_PRIORITY, &taskHandle) !=
         pdPASS)
@@ -122,31 +123,42 @@ void chip::NXP::App::AppTaskFreeRTOS::AppTaskMain(void * pvParameter)
 
     sAppTask->PreInitMatterStack();
     err = sAppTask->Init();
+    VerifyOrDieWithMsg(err == CHIP_NO_ERROR, DeviceLayer, "AppTask.Init() failed");
     sAppTask->PostInitMatterStack();
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(DeviceLayer, "AppTask.Init() failed");
-        assert(err == CHIP_NO_ERROR);
-    }
 
     while (true)
     {
-        BaseType_t eventReceived = xQueueReceive(sAppEventQueue, &event, portMAX_DELAY);
+        BaseType_t eventReceived = xQueueReceive(sAppTask->appEventQueue, &event, sAppTask->ticksToWait);
         while (eventReceived == pdTRUE)
         {
             sAppTask->DispatchEvent(event);
-            eventReceived = xQueueReceive(sAppEventQueue, &event, 0);
+            eventReceived = xQueueReceive(sAppTask->appEventQueue, &event, 0);
         }
+
+        sAppTask->PostEventsProcessedAction();
     }
 }
 
 void chip::NXP::App::AppTaskFreeRTOS::PostEvent(const AppEvent & event)
 {
-    if (sAppEventQueue != NULL)
+    if (appEventQueue != NULL)
     {
-        if (!xQueueSend(sAppEventQueue, &event, 0))
+        if (__get_IPSR())
+        {
+            portBASE_TYPE taskToWake = pdFALSE;
+            if (!xQueueSendToFrontFromISR(appEventQueue, &event, &taskToWake))
+            {
+                ChipLogError(DeviceLayer, "Failed to post event to app task event queue from ISR");
+            }
+
+            portYIELD_FROM_ISR(taskToWake);
+        }
+        else
         {
-            ChipLogError(DeviceLayer, "Failed to post event to app task event queue");
+            if (!xQueueSend(appEventQueue, &event, 0))
+            {
+                ChipLogError(DeviceLayer, "Failed to post event to app task event queue");
+            }
         }
     }
 }