14 files changed, 232 insertions(+), 7 deletions(-)

M module-apps/apps-common/ApplicationCommon.hpp
M products/BellHybrid/apps/Application.cpp
M products/BellHybrid/apps/CMakeLists.txt
M products/BellHybrid/apps/application-bell-main/ApplicationBellMain.cpp
M products/BellHybrid/apps/application-bell-main/include/application-bell-main/ApplicationBellMain.hpp
M products/BellHybrid/apps/application-bell-powernap/ApplicationBellPowerNap.cpp
M products/BellHybrid/apps/application-bell-powernap/include/application-bell-powernap/ApplicationBellPowerNap.hpp
M products/BellHybrid/apps/include/Application.hpp
M products/BellHybrid/services/appmgr/ApplicationManager.cpp
M products/BellHybrid/services/appmgr/CMakeLists.txt
A products/BellHybrid/services/appmgr/IdleHandler.cpp
M products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp
A products/BellHybrid/services/appmgr/include/appmgr/IdleHandler.hpp
A products/BellHybrid/services/appmgr/include/appmgr/messages/IdleTimerMessage.hpp

@@ 173,6 173,13 @@ namespace app
 
         using OnActionReceived = std::function<ActionResult(manager::actions::ActionParamsPtr &&)>;
 
+      protected:
+        virtual sys::MessagePointer handleKBDKeyEvent(sys::Message *msgl);
+        virtual sys::MessagePointer handleApplicationSwitch(sys::Message *msgl);
+        virtual sys::MessagePointer handleAppClose(sys::Message *msgl);
+        virtual sys::MessagePointer handleSwitchWindow(sys::Message *msgl);
+        virtual sys::MessagePointer handleAppFocusLost(sys::Message *msgl);
+
       private:
         std::string default_window;
         State state = State::DEACTIVATED;


@@ 180,20 187,15 @@ namespace app
         sys::MessagePointer handleSignalStrengthUpdate(sys::Message *msgl);
         sys::MessagePointer handleNetworkAccessTechnologyUpdate(sys::Message *msgl);
         sys::MessagePointer handleInputEvent(sys::Message *msgl);
-        sys::MessagePointer handleKBDKeyEvent(sys::Message *msgl);
         sys::MessagePointer handleBatteryStatusChange();
         sys::MessagePointer handleMinuteUpdated(sys::Message *msgl);
         sys::MessagePointer handleAction(sys::Message *msgl);
-        sys::MessagePointer handleApplicationSwitch(sys::Message *msgl);
         sys::MessagePointer handleApplicationSwitchLaunch(sys::Message *msgl);
         sys::MessagePointer handleApplicationSwitchOnAction(sys::Message *msgl);
-        sys::MessagePointer handleSwitchWindow(sys::Message *msgl);
         sys::MessagePointer handleUpdateWindow(sys::Message *msgl);
-        sys::MessagePointer handleAppClose(sys::Message *msgl);
         sys::MessagePointer handleAppRebuild(sys::Message *msgl);
         sys::MessagePointer handleAppRefresh(sys::Message *msgl);
         sys::MessagePointer handleGetDOM(sys::Message *msgl);
-        sys::MessagePointer handleAppFocusLost(sys::Message *msgl);
         sys::MessagePointer handleSimStateUpdateMessage(sys::Message *msgl);
 
         virtual bool isPopupPermitted(gui::popup::ID popupId) const;

@@ 5,6 5,7 @@
 
 #include <common/models/AlarmModel.hpp>
 
+#include <appmgr/messages/IdleTimerMessage.hpp>
 #include <common/BellPowerOffPresenter.hpp>
 #include <common/popups/presenter/AlarmActivatedPresenter.hpp>
 #include <common/popups/AlarmActivatedWindow.hpp>


@@ 13,6 14,7 @@
 #include <common/popups/BellRebootWindow.hpp>
 #include <common/windows/BellTurnOffWindow.hpp>
 #include <common/windows/BellWelcomeWindow.hpp>
+#include <service-appmgr/Constants.hpp>
 
 namespace app
 {


@@ 68,4 70,58 @@ namespace app
                    (isCurrentWindow(gui::popup::resolveWindowName(gui::popup::ID::PowerOff))) ||
                    (isCurrentWindow(gui::BellTurnOffWindow::name)));
     }
+
+    sys::MessagePointer Application::handleKBDKeyEvent(sys::Message *msgl)
+    {
+        onKeyPressed();
+        return ApplicationCommon::handleKBDKeyEvent(msgl);
+    }
+
+    sys::MessagePointer Application::handleApplicationSwitch(sys::Message *msgl)
+    {
+        onStart();
+        return ApplicationCommon::handleApplicationSwitch(msgl);
+    }
+
+    sys::MessagePointer Application::handleAppClose(sys::Message *msgl)
+    {
+        onStop();
+        return ApplicationCommon::handleAppClose(msgl);
+    }
+
+    sys::MessagePointer Application::handleAppFocusLost(sys::Message *msgl)
+    {
+        onStop();
+        return ApplicationCommon::handleAppFocusLost(msgl);
+    }
+
+    void Application::onKeyPressed()
+    {
+        restartIdleTimer();
+    }
+
+    void Application::onStart()
+    {
+        startIdleTimer();
+    }
+
+    void Application::onStop()
+    {
+        stopIdleTimer();
+    }
+
+    void Application::startIdleTimer()
+    {
+        bus.sendUnicast(std::make_shared<StartIdleTimerMessage>(), service::name::appmgr);
+    }
+
+    void Application::restartIdleTimer()
+    {
+        bus.sendUnicast(std::make_shared<RestartIdleTimerMessage>(), service::name::appmgr);
+    }
+
+    void Application::stopIdleTimer()
+    {
+        bus.sendUnicast(std::make_shared<StopIdleTimerMessage>(), service::name::appmgr);
+    }
 } // namespace app

@@ 16,6 16,7 @@ target_link_libraries(app
     PRIVATE
         apps-common
         bell::app-common
+        bell::appmgr
 )
 
 add_subdirectory(application-bell-main)

@@ 9,6 9,7 @@
 #include "windows/BellHomeScreenWindow.hpp"
 #include "windows/BellMainMenuWindow.hpp"
 
+#include <apps-common/messages/AppMessage.hpp>
 #include <common/models/AlarmModel.hpp>
 #include <common/models/TimeModel.hpp>
 #include <service-db/DBNotificationMessage.hpp>


@@ 102,4 103,24 @@ namespace app
     {
         return GetName() == app::applicationBellName && getCurrentWindow()->getName() == gui::name::window::main_window;
     }
+
+    // Empty: do not start idleTimer on application run
+    void ApplicationBellMain::onStart()
+    {}
+
+    sys::MessagePointer ApplicationBellMain::handleSwitchWindow(sys::Message *msgl)
+    {
+        auto msg = static_cast<AppSwitchWindowMessage *>(msgl);
+        if (msg) {
+            const auto newWindowName = msg->getWindowName();
+            if (newWindowName == gui::name::window::main_window) {
+                stopIdleTimer();
+            }
+            else if (newWindowName == gui::window::name::bell_main_menu ||
+                     newWindowName == gui::window::name::bell_main_menu_dialog) {
+                startIdleTimer();
+            }
+        }
+        return ApplicationCommon::handleSwitchWindow(msgl);
+    }
 } // namespace app

@@ 41,6 41,8 @@ namespace app
       private:
         void showPopup(gui::popup::ID id, const gui::PopupRequestParams *params) override;
         auto isHomeScreenFocused() -> bool;
+        void onStart() override;
+        sys::MessagePointer handleSwitchWindow(sys::Message *msgl) override;
     };
 
     template <> struct ManifestTraits<ApplicationBellMain>

@@ 71,4 71,8 @@ namespace app
 
         return handleAsyncResponse(resp);
     }
+
+    // Empty: do not start idleTimer on application run
+    void ApplicationBellPowerNap::onStart()
+    {}
 } // namespace app

@@ 41,6 41,9 @@ namespace app
         {
             return sys::ReturnCodes::Success;
         }
+
+      private:
+        void onStart() override;
     };
 
     template <> struct ManifestTraits<ApplicationBellPowerNap>

@@ 15,5 15,18 @@ namespace app
       protected:
         void attachPopups(const std::vector<gui::popup::ID> &popupsList) override;
         bool isPopupPermitted(gui::popup::ID popupId) const override;
+        void startIdleTimer();
+        void restartIdleTimer();
+        void stopIdleTimer();
+
+      private:
+        sys::MessagePointer handleKBDKeyEvent(sys::Message *msgl) override;
+        sys::MessagePointer handleApplicationSwitch(sys::Message *msgl) override;
+        sys::MessagePointer handleAppClose(sys::Message *msgl) override;
+        sys::MessagePointer handleAppFocusLost(sys::Message *msgl) override;
+
+        virtual void onKeyPressed();
+        virtual void onStart();
+        virtual void onStop();
     };
 } // namespace app

@@ 3,6 3,8 @@
 
 #include <appmgr/ApplicationManager.hpp>
 #include <appmgr/messages/AlarmMessage.hpp>
+#include <appmgr/messages/IdleTimerMessage.hpp>
+
 #include <application-bell-onboarding/BellOnBoardingNames.hpp>
 
 namespace app::manager


@@ 10,7 12,7 @@ namespace app::manager
     ApplicationManager::ApplicationManager(const ApplicationName &serviceName,
                                            std::vector<std::unique_ptr<app::ApplicationLauncher>> &&launchers,
                                            const ApplicationName &_rootApplicationName)
-        : ApplicationManagerCommon(serviceName, std::move(launchers), _rootApplicationName)
+        : ApplicationManagerCommon(serviceName, std::move(launchers), _rootApplicationName), IdleHandler(this)
     {
         registerMessageHandlers();
     }


@@ 37,6 39,18 @@ namespace app::manager
         ApplicationManagerCommon::registerMessageHandlers();
 
         auto convertibleToActionHandler = [this](sys::Message *request) { return handleMessageAsAction(request); };
+        connect(typeid(StartIdleTimerMessage), [this](sys::Message *request) {
+            handleStartIdleTimer(request);
+            return sys::msgHandled();
+        });
+        connect(typeid(RestartIdleTimerMessage), [this](sys::Message *request) {
+            handleRestartIdleTimer(request);
+            return sys::msgHandled();
+        });
+        connect(typeid(StopIdleTimerMessage), [this](sys::Message *request) {
+            handleStopIdleTimer(request);
+            return sys::msgHandled();
+        });
         connect(typeid(AlarmActivated), convertibleToActionHandler);
         connect(typeid(AlarmDeactivated), convertibleToActionHandler);
     }

@@ 4,9 4,11 @@ add_library(bell::appmgr ALIAS appmgr)
 target_sources(appmgr
     PRIVATE
         ApplicationManager.cpp
+        IdleHandler.cpp
     PUBLIC
         include/appmgr/messages/AlarmMessage.hpp
         include/appmgr/ApplicationManager.hpp
+        include/appmgr/IdleHandler.hpp
         include/appmgr/messages/PowerOffPopupRequestParams.hpp
         include/appmgr/messages/RebootPopupRequestParams.hpp
 )

@@ 0,0 1,41 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include <appmgr/IdleHandler.hpp>
+#include <appmgr/messages/IdleTimerMessage.hpp>
+
+#include <service-appmgr/Controller.hpp>
+#include <Timers/TimerFactory.hpp>
+
+namespace app::manager
+{
+    IdleHandler::IdleHandler(sys::Service *serv) : serv{serv}
+    {
+        idleTimer = sys::TimerFactory::createPeriodicTimer(
+            serv, "IdleReturn", idleReturnTimeout, [this](sys::Timer &) { idleTimerCallback(); });
+    }
+
+    void IdleHandler::handleStartIdleTimer(sys::Message *request)
+    {
+        idleTimer.restart(idleReturnTimeout);
+    }
+
+    void IdleHandler::handleRestartIdleTimer(sys::Message *request)
+    {
+        if (idleTimer.isActive()) {
+            idleTimer.restart(idleReturnTimeout);
+        }
+    }
+
+    void IdleHandler::handleStopIdleTimer(sys::Message *request)
+    {
+        idleTimer.stop();
+    }
+
+    void IdleHandler::idleTimerCallback()
+    {
+        LOG_INFO("User is idle - going back to home screen");
+        idleTimer.stop();
+        app::manager::Controller::sendAction(serv, app::manager::actions::Home);
+    }
+} // namespace app::manager

@@ 3,11 3,12 @@
 
 #pragma once
 
+#include <appmgr/IdleHandler.hpp>
 #include <service-appmgr/model/ApplicationManagerCommon.hpp>
 
 namespace app::manager
 {
-    class ApplicationManager : public ApplicationManagerCommon
+    class ApplicationManager : public ApplicationManagerCommon, public IdleHandler
     {
       public:
         ApplicationManager(const ApplicationName &serviceName,


@@ 15,6 16,8 @@ namespace app::manager
                            const ApplicationName &_rootApplicationName);
 
       private:
+        sys::TimerHandle idleTimer;
+
         auto startApplication(ApplicationHandle &app) -> bool override;
         auto resolveHomeApplication() -> std::string override;
         void registerMessageHandlers() override;

@@ 0,0 1,32 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <Service/Service.hpp>
+#include <Service/Message.hpp>
+#include <Timers/TimerHandle.hpp>
+
+#include <chrono>
+
+namespace app::manager
+{
+    constexpr auto idleReturnTimeout = std::chrono::seconds{5};
+    using connectFunction            = std::function<bool(const std::type_info &, sys::MessageHandler)>;
+
+    class IdleHandler
+    {
+      public:
+        IdleHandler(sys::Service *serv);
+
+      protected:
+        void handleStartIdleTimer(sys::Message *request);
+        void handleRestartIdleTimer(sys::Message *request);
+        void handleStopIdleTimer(sys::Message *request);
+        void idleTimerCallback();
+
+      private:
+        sys::Service *serv;
+        sys::TimerHandle idleTimer;
+    };
+} // namespace app::manager

@@ 0,0 1,31 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <Service/Message.hpp>
+#include <popups/AlarmActivatedPopupRequestParams.hpp>
+#include <popups/AlarmDeactivatedPopupRequestParams.hpp>
+#include <service-appmgr/Actions.hpp>
+#include <service-appmgr/messages/ActionRequest.hpp>
+
+class StartIdleTimerMessage : public sys::DataMessage
+{
+  public:
+    StartIdleTimerMessage() : sys::DataMessage{MessageType::MessageTypeUninitialized}
+    {}
+};
+
+class RestartIdleTimerMessage : public sys::DataMessage
+{
+  public:
+    RestartIdleTimerMessage() : sys::DataMessage{MessageType::MessageTypeUninitialized}
+    {}
+};
+
+class StopIdleTimerMessage : public sys::DataMessage
+{
+  public:
+    StopIdleTimerMessage() : sys::DataMessage{MessageType::MessageTypeUninitialized}
+    {}
+};