[EGD-4151] Application manager actions introduced. (#905)

* [EGD-4151] Application manifest structure defined.
* [EGD-4156] Applications registry and basic action handler implemented.

Author: Piotr Tanski

changelog.md

@@ -15,6 +15,7 @@
 
 * `[cellular]` Handled properly SIM READY and SIM PIN URC messages with Action mockup
 * `[calendar]` Rework to use database model instead of internal model in day events list.
+* `[appmgr]` Application manager actions introduced.
 
 ### Fixed
 

module-apps/Application.cpp

@@ -62,16 +62,16 @@ namespace app
         }
     }
 
-    Application::Application(
-        std::string name, std::string parent, bool startBackground, uint32_t stackDepth, sys::ServicePriority priority)
+    Application::Application(std::string name,
+                             std::string parent,
+                             StartInBackground startInBackground,
+                             uint32_t stackDepth,
+                             sys::ServicePriority priority)
         : Service(name, parent, stackDepth, priority), default_window(gui::name::window::main_window),
-          windowsStack(this), windowsFactory(), startBackground{startBackground}
+          windowsStack(this), startInBackground{startInBackground}
     {
         keyTranslator = std::make_unique<gui::KeyInputSimpleTranslation>();
         busChannels.push_back(sys::BusChannels::ServiceCellularNotifications);
-        if (startBackground) {
-            setState(State::ACTIVE_BACKGROUND);
-        }
 
         longPressTimer = std::make_unique<sys::Timer>("LongPress", this, key_timer_ms);
         longPressTimer->connect([&](sys::Timer &) { longPressTimerCallback(); });
@@ -223,6 +223,9 @@ namespace app
         else if (msgl->messageType == MessageType::EVMMinuteUpdated) {
             return handleMinuteUpdated(msgl);
         }
+        else if (msgl->messageType == MessageType::AppAction) {
+            return handleAction(msgl);
+        }
         else if (msgl->messageType == MessageType::AppSwitch) {
             return handleApplicationSwitch(msgl);
         }
@@ -333,6 +336,21 @@ namespace app
         return msgHandled();
     }
 
+    sys::Message_t Application::handleAction(sys::DataMessage *msgl)
+    {
+        auto *msg         = static_cast<AppActionRequest *>(msgl);
+        const auto action = msg->getAction();
+        try {
+            const auto &actionHandler = receivers.at(action);
+            auto &data                = msg->getData();
+            actionHandler(std::move(data));
+        }
+        catch (const std::out_of_range &) {
+            LOG_ERROR("Application %s is not able to handle action #%d", GetName().c_str(), action);
+        }
+        return msgHandled();
+    }
+
     sys::Message_t Application::handleApplicationSwitch(sys::DataMessage *msgl)
     {
         auto *msg             = static_cast<AppSwitchMessage *>(msgl);
@@ -472,12 +490,16 @@ namespace app
         setState(State::INITIALIZING);
         settings = DBServiceAPI::SettingsGet(this);
 
-        const bool initialised = settings.dbID == 1;
-        app::manager::Controller::registerApplication(this, initialised, startBackground);
-        if (!initialised) {
+        const auto status = (settings.dbID == 1) ? StartupStatus::Success : StartupStatus::Failure;
+        app::manager::Controller::applicationInitialised(this, status, startInBackground);
+        if (status == StartupStatus::Failure) {
             setState(State::DEACTIVATED);
             return sys::ReturnCodes::Failure;
         }
+
+        if (startInBackground) {
+            setState(State::ACTIVE_BACKGROUND);
+        }
         return sys::ReturnCodes::Success;
     }
 
@@ -507,6 +529,15 @@ namespace app
         return AudioServiceAPI::KeyPressed(this, step);
     }
 
+    void Application::requestAction(sys::Service *sender,
+                                    const ApplicationName &applicationName,
+                                    manager::actions::ActionId actionId,
+                                    manager::actions::ActionParamsPtr &&data)
+    {
+        auto msg = std::make_shared<AppActionRequest>(actionId, std::move(data));
+        sys::Bus::SendUnicast(msg, applicationName, sender);
+    }
+
     void Application::messageSwitchApplication(sys::Service *sender,
                                                std::string application,
                                                std::string window,
@@ -616,4 +647,9 @@ namespace app
         timer->sysapi.connect(item);
         item->attachTimer(std::move(timer));
     }
+
+    void Application::addActionReceiver(manager::actions::ActionId actionId, OnActionReceived &&callback)
+    {
+        receivers.insert_or_assign(actionId, std::move(callback));
+    }
 } /* namespace app */

module-apps/Application.hpp

@@ -17,6 +17,7 @@
 #include "gui/Common.hpp"                               // for ShowMode
 #include "projdefs.h"                                   // for pdMS_TO_TICKS
 #include "service-evtmgr/messages/EVMessages.hpp"       // for TorchStateMe...
+#include "module-services/service-appmgr/ApplicationManifest.hpp"
 #include <list>                                         // for list
 #include <map>                                          // for allocator, map
 #include <memory>                                       // for make_shared
@@ -57,7 +58,6 @@ namespace sys
 
 namespace app
 {
-
     class Application;
     class GuiTimer;
 
@@ -71,6 +71,49 @@ namespace app
         return std::make_shared<sys::ResponseMessage>(sys::ReturnCodes::Unresolved);
     }
 
+    using ApplicationName = std::string;
+
+    enum class StartupStatus
+    {
+        Success,
+        Failure
+    };
+
+    struct StartInBackground
+    {
+        StartInBackground(bool _value) : value{_value}
+        {}
+
+        explicit operator bool() const noexcept
+        {
+            return value;
+        }
+
+        bool value;
+    };
+
+    /// Type traits pattern used to enforce user-defined types to implement "GetManifest" function.
+    template <class T> struct ManifestTraits;
+
+    template <class, class = void> struct HasManifest : std::false_type
+    {};
+
+    /// Checks whether T implements "GetManifest" static method.
+    /// Provides the member constant "value" that is equal to true if T implements "GetManifest" static method.
+    /// Otherwise, "value" is equal to false.
+    template <class T>
+    struct HasManifest<T, std::void_t<decltype(&ManifestTraits<T>::GetManifest)>>
+        : std::is_same<app::manager::ApplicationManifest, decltype(ManifestTraits<T>::GetManifest())>
+    {};
+
+    /// Retrieves the manifest of T, if T implements ManifestTraits.
+    /// Otherwise, reports an error during compile time.
+    template <class T, std::enable_if_t<HasManifest<T>::value, int> = 0>
+    auto ManifestOf() -> manager::ApplicationManifest
+    {
+        return ManifestTraits<T>::GetManifest();
+    }
+
     /// This is template for creating new applications. Main difference between Application and service is that:
     /// 1. Application has access to GUI and Input
     /// 2. Application lifetime is managed with app::manager::ApplicationManager
@@ -111,6 +154,8 @@ namespace app
         /// c_str() function for Application::State
         static const char *stateStr(State st);
 
+        using OnActionReceived = std::function<void(manager::actions::ActionParamsPtr &&)>;
+
       private:
         std::string default_window;
         State state = State::DEACTIVATED;
@@ -122,6 +167,7 @@ namespace app
         sys::Message_t handleBatteryLevel(sys::DataMessage *msgl);
         sys::Message_t handleChargerPlugged(sys::DataMessage *msgl);
         sys::Message_t handleMinuteUpdated(sys::DataMessage *msgl);
+        sys::Message_t handleAction(sys::DataMessage *msgl);
         sys::Message_t handleApplicationSwitch(sys::DataMessage *msgl);
         sys::Message_t handleSwitchWindow(sys::DataMessage *msgl);
         sys::Message_t handleAppClose(sys::DataMessage *msgl);
@@ -131,14 +177,15 @@ namespace app
         sys::Message_t handleSIMMessage(sys::DataMessage *msgl);
 
         std::list<std::unique_ptr<app::GuiTimer>> gui_timers;
+        std::unordered_map<manager::actions::ActionId, OnActionReceived> receivers;
 
       public:
         std::unique_ptr<sys::Timer> longPressTimer;
         Application(std::string name,
-                    std::string parent            = "",
-                    bool startBackground          = false,
-                    uint32_t stackDepth           = 4096,
-                    sys::ServicePriority priority = sys::ServicePriority::Idle);
+                    std::string parent                  = "",
+                    StartInBackground startInBackground = {false},
+                    uint32_t stackDepth                 = 4096,
+                    sys::ServicePriority priority       = sys::ServicePriority::Idle);
 
         virtual ~Application();
 
@@ -287,6 +334,10 @@ namespace app
         /// @note consider moving these as private elements of ApplicationManager i.e. under names
         /// message::switchApplication etc.
         /// @{
+        static void requestAction(sys::Service *sender,
+                                  const ApplicationName &applicationName,
+                                  manager::actions::ActionId actionId,
+                                  manager::actions::ActionParamsPtr &&data);
         static void messageSwitchApplication(sys::Service *sender,
                                              std::string application,
                                              std::string window,
@@ -343,7 +394,7 @@ namespace app
         /// 2. simple translation of keys 1 to 1 with keyboard
         std::unique_ptr<gui::KeyInputSimpleTranslation> keyTranslator;
         /// Flag defines how application will behave after registration. It can go forground or background
-        bool startBackground = false;
+        StartInBackground startInBackground{false};
         /// Flag which defines whether application initialized suspend mode, this will influence how render message will
         /// sent to gui service. If suspend is true, application manager will receive information from both eink and gui
         /// services if last rendering mesage will be processed.
@@ -358,6 +409,24 @@ namespace app
         static void messageInputEventApplication(sys::Service *sender,
                                                  std::string application,
                                                  const gui::InputEvent &event);
+
+        void addActionReceiver(manager::actions::ActionId actionId, OnActionReceived &&callback);
     };
 
+    /// Parameter pack used by application launch action.
+    class ApplicationLaunchData : public manager::actions::ActionParams
+    {
+      public:
+        ApplicationLaunchData(const app::ApplicationName &appName)
+            : manager::actions::ActionParams{"Application launch parameters"}, targetAppName{appName}
+        {}
+
+        [[nodiscard]] auto getTargetApplicationName() const noexcept
+        {
+            return targetAppName;
+        }
+
+      private:
+        ApplicationName targetAppName;
+    };
 } /* namespace app */

module-apps/ApplicationLauncher.hpp

@@ -7,6 +7,7 @@
 
 namespace app
 {
+    using ApplicationManifest = app::manager::ApplicationManifest;
 
     /// used in ApplicationManager to start applications
     class ApplicationLauncher
@@ -16,6 +17,8 @@ namespace app
         std::string name;
         /// name of the application's owner
         std::string parent;
+        /// Application's manifest
+        ApplicationManifest manifest;
         /// defines whether application can be closed when it looses focus
         bool closeable = true;
         /// defines whether application should be run without gaining focus, it will remian in the BACKGROUND state
@@ -24,15 +27,23 @@ namespace app
         bool preventBlocking = false;
 
       public:
-        ApplicationLauncher(std::string name, bool isCloseable, bool preventBlocking = false)
-            : name{name}, closeable{isCloseable}, preventBlocking{preventBlocking} {};
+        ApplicationLauncher(std::string name,
+                            ApplicationManifest &&manifest,
+                            bool isCloseable,
+                            bool preventBlocking = false)
+            : name{name}, manifest{std::move(manifest)}, closeable{isCloseable}, preventBlocking{preventBlocking} {};
         virtual ~ApplicationLauncher() = default;
 
         [[nodiscard]] std::string getName() const noexcept
         {
             return name;
         }
 
+        [[nodiscard]] const ApplicationManifest &getManifest() const noexcept
+        {
+            return manifest;
+        }
+
         [[nodiscard]] bool isCloseable() const noexcept
         {
             return closeable;
@@ -60,7 +71,8 @@ namespace app
     template <class T> class ApplicationLauncherT : public ApplicationLauncher
     {
       public:
-        ApplicationLauncherT(std::string name, bool isCloseable = true) : ApplicationLauncher(name, isCloseable)
+        ApplicationLauncherT(std::string name, ApplicationManifest &&manifest, bool isCloseable = true)
+            : ApplicationLauncher(name, std::move(manifest), isCloseable)
         {}
 
         bool run(sys::Service *caller) override
@@ -82,6 +94,7 @@ namespace app
     template <class T>
     std::unique_ptr<ApplicationLauncherT<T>> CreateLauncher(std::string name, bool isCloseable = true)
     {
-        return std::unique_ptr<ApplicationLauncherT<T>>(new ApplicationLauncherT<T>(name, isCloseable));
+        return std::unique_ptr<ApplicationLauncherT<T>>(
+            new ApplicationLauncherT<T>(name, ManifestOf<T>(), isCloseable));
     }
 } // namespace app

module-apps/UiCommonActions.cpp

@@ -12,7 +12,7 @@
 #include "application-special-input/ApplicationSpecialInput.hpp"
 
 #include "service-appmgr/Controller.hpp"
-#include "service-appmgr/messages/APMMessage.hpp"
+#include "service-appmgr/messages/Message.hpp"
 
 #include <i18/i18.hpp>
 #include <log/log.hpp>
@@ -40,10 +40,8 @@ namespace app
     auto call(Application *app, const utils::PhoneNumber::View &phoneNumber) -> bool
     {
         assert(app != nullptr);
-        auto data             = std::make_unique<ExecuteCallData>(phoneNumber);
-        data->disableAppClose = true;
-
-        return app::manager::Controller::switchApplication(app, name_call, window::name_enterNumber, std::move(data));
+        auto data = std::make_unique<ExecuteCallData>(phoneNumber);
+        return app::manager::Controller::sendAction(app, manager::actions::Call, std::move(data));
     }
 
     auto prepareCall(Application *app, const std::string &number) -> bool
@@ -169,6 +167,6 @@ namespace app
                 app, app::special_input, app::char_select, std::move(switchData));
         }
         return app::manager::Controller::switchBack(
-            app, std::make_unique<app::manager::APMSwitchPrevApp>(switchData->requester, std::move(switchData)));
+            app, std::make_unique<app::manager::SwitchBackRequest>(switchData->requester, std::move(switchData)));
     }
 } // namespace app

module-apps/application-antenna/ApplicationAntenna.cpp

@@ -34,8 +34,8 @@ namespace app
         }
     }
 
-    ApplicationAntenna::ApplicationAntenna(std::string name, std::string parent, bool startBackgound)
-        : Application(name, parent, startBackgound, 4096 * 2)
+    ApplicationAntenna::ApplicationAntenna(std::string name, std::string parent, StartInBackground startInBackground)
+        : Application(name, parent, startInBackground, 4096 * 2)
     {
         busChannels.push_back(sys::BusChannels::AntennaNotifications);
         busChannels.push_back(sys::BusChannels::AntennaNotifications);

module-apps/application-antenna/ApplicationAntenna.hpp

@@ -30,6 +30,7 @@ namespace app
         };
         constexpr uint32_t paramsMaxSize = 9;
     } // namespace antenna
+
     class ApplicationAntenna : public app::Application
     {
       protected:
@@ -44,7 +45,9 @@ namespace app
         uint32_t lastFreq = 0;
 
       public:
-        ApplicationAntenna(std::string name = name_antenna, std::string parent = "", bool startBackgound = false);
+        ApplicationAntenna(std::string name                    = name_antenna,
+                           std::string parent                  = {},
+                           StartInBackground startInBackground = {false});
         virtual ~ApplicationAntenna();
 
         sys::Message_t DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp) override;
@@ -73,6 +76,13 @@ namespace app
         std::vector<app::antenna::StoreParams> highBandParams;
     };
 
+    template <> struct ManifestTraits<ApplicationAntenna>
+    {
+        static auto GetManifest() -> manager::ApplicationManifest
+        {
+            return {{manager::actions::Launch}};
+        }
+    };
 } /* namespace app */
 
 #endif /* MODULE_APPS_APPLICATION_ANTENNA_APPLICATIONANTENNA_HPP_ */