From e1ef8216096226cc74d35626803848f22da1cf66 Mon Sep 17 00:00:00 2001 From: Mateusz Grzegorzek Date: Fri, 6 Aug 2021 09:50:04 +0200 Subject: [PATCH] [BH-741] Split ApplicationManager Separate Pure and Bell ApplicationManager functionalities to separate files. --- .../windows/CallLogDetailsWindow.cpp | 1 - .../windows/CallLogMainWindow.cpp | 1 - .../application-clock/ApplicationClock.cpp | 1 - .../models/ActiveNotificationsModel.cpp | 3 +- .../windows/ChargingBatteryWindow.cpp | 1 - .../windows/DeadBatteryWindow.cpp | 1 - .../windows/MmiInternalMsgWindow.cpp | 1 - .../windows/MmiPullWindow.cpp | 1 - .../windows/MmiPushWindow.cpp | 2 +- .../windows/MessagesMainWindow.cpp | 1 - .../ApplicationOnBoarding.cpp | 7 +- .../ApplicationSettings.cpp | 8 +- module-apps/apps-common/Application.cpp | 1 + .../locks/handlers/PhoneLockSubject.cpp | 19 +- .../locks/handlers/SimLockSubject.cpp | 16 +- module-apps/apps-common/windows/Dialog.cpp | 2 +- .../apps-common/windows/OptionWindow.cpp | 1 - .../service-antenna/ServiceAntenna.cpp | 1 - module-services/service-appmgr/CMakeLists.txt | 5 +- module-services/service-appmgr/Controller.cpp | 26 +- .../include/service-appmgr/Constants.hpp | 9 + .../include/service-appmgr/Controller.hpp | 1 - .../service-appmgr/model/ActionsRegistry.hpp | 3 +- ...nager.hpp => ApplicationManagerCommon.hpp} | 84 +-- .../service-appmgr/model/ActionsRegistry.cpp | 2 + ...nager.cpp => ApplicationManagerCommon.cpp} | 527 +++--------------- .../CellularRequestHandler.cpp | 20 +- .../service-cellular/CellularUrcHandler.cpp | 5 +- .../service-cellular/ServiceCellular.cpp | 4 +- .../src/ServiceCellularPriv.cpp | 4 +- .../service-desktop/ServiceDesktop.cpp | 8 +- .../developerMode/DeveloperModeHelper.cpp | 1 + .../developerMode/Mode/UI_Helper.cpp | 4 +- .../security/SecurityEndpointHelper.cpp | 7 +- module-sys/SystemManager/SystemManager.cpp | 29 +- products/BellHybrid/BellHybridMain.cpp | 5 +- products/BellHybrid/CMakeLists.txt | 1 + products/BellHybrid/services/CMakeLists.txt | 1 + .../services/appmgr/ApplicationManager.cpp | 26 + .../BellHybrid/services/appmgr/CMakeLists.txt | 19 + .../include/appmgr/ApplicationManager.hpp | 25 + products/PurePhone/CMakeLists.txt | 1 + products/PurePhone/PurePhoneMain.cpp | 10 +- products/PurePhone/services/CMakeLists.txt | 1 + .../services/appmgr/ApplicationManager.cpp | 478 ++++++++++++++++ .../PurePhone/services/appmgr/CMakeLists.txt | 27 + .../include/appmgr/ApplicationManager.hpp | 56 ++ 47 files changed, 836 insertions(+), 621 deletions(-) create mode 100644 module-services/service-appmgr/include/service-appmgr/Constants.hpp rename module-services/service-appmgr/include/service-appmgr/model/{ApplicationManager.hpp => ApplicationManagerCommon.hpp} (66%) rename module-services/service-appmgr/model/{ApplicationManager.cpp => ApplicationManagerCommon.cpp} (53%) create mode 100644 products/BellHybrid/services/appmgr/ApplicationManager.cpp create mode 100644 products/BellHybrid/services/appmgr/CMakeLists.txt create mode 100644 products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp create mode 100644 products/PurePhone/services/appmgr/ApplicationManager.cpp create mode 100644 products/PurePhone/services/appmgr/CMakeLists.txt create mode 100644 products/PurePhone/services/appmgr/include/appmgr/ApplicationManager.hpp diff --git a/module-apps/application-calllog/windows/CallLogDetailsWindow.cpp b/module-apps/application-calllog/windows/CallLogDetailsWindow.cpp index c72d0e8d506bbd12ba027957ad0ec51027b91fad..135ee24e2a123e75a027554297e9632ded271ce5 100644 --- a/module-apps/application-calllog/windows/CallLogDetailsWindow.cpp +++ b/module-apps/application-calllog/windows/CallLogDetailsWindow.cpp @@ -6,7 +6,6 @@ #include #include -#include #include "ApplicationCallLog.hpp" #include "data/CallLogInternals.hpp" #include "data/CallLogSwitchData.hpp" diff --git a/module-apps/application-calllog/windows/CallLogMainWindow.cpp b/module-apps/application-calllog/windows/CallLogMainWindow.cpp index af3466590d1340fcb430c87919184536f387aa0a..eb0f2668150a64be9d12e2bee16a157a68385a70 100644 --- a/module-apps/application-calllog/windows/CallLogMainWindow.cpp +++ b/module-apps/application-calllog/windows/CallLogMainWindow.cpp @@ -6,7 +6,6 @@ #include "ApplicationCallLog.hpp" #include "widgets/CalllogItem.hpp" -#include #include #include #include diff --git a/module-apps/application-clock/ApplicationClock.cpp b/module-apps/application-clock/ApplicationClock.cpp index 86322c8e05a0f0eaaf5d7ded3ea4db4324e2502b..9b0f7418ab7ae4aff5236873cc44ec61938dc040 100644 --- a/module-apps/application-clock/ApplicationClock.cpp +++ b/module-apps/application-clock/ApplicationClock.cpp @@ -9,7 +9,6 @@ #include #include #include -#include #include // MessageType #include "MessageType.hpp" diff --git a/module-apps/application-desktop/models/ActiveNotificationsModel.cpp b/module-apps/application-desktop/models/ActiveNotificationsModel.cpp index d3878d46c8bbc15dd0957eb6aca0d953d9175733..49920c2f38b796a898d2d9030576dd927cb5cce6 100644 --- a/module-apps/application-desktop/models/ActiveNotificationsModel.cpp +++ b/module-apps/application-desktop/models/ActiveNotificationsModel.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -51,7 +52,7 @@ namespace auto data = std::make_unique(std::make_shared(result->getThread())); auto request = std::make_shared( app->GetName(), app::name_messages, gui::name::window::thread_view, std::move(data)); - return app->bus.sendUnicast(std::move(request), app::manager::ApplicationManager::ServiceName); + return app->bus.sendUnicast(std::move(request), service::name::appmgr); }; task->setCallback(std::move(queryCallback)); task->execute(app, static_cast(app)); diff --git a/module-apps/application-desktop/windows/ChargingBatteryWindow.cpp b/module-apps/application-desktop/windows/ChargingBatteryWindow.cpp index 6a023195c2b86c05eb65cccc83f103342b472e80..c5de7ed1a36f50e040895531d3f92ba2bd04b30c 100644 --- a/module-apps/application-desktop/windows/ChargingBatteryWindow.cpp +++ b/module-apps/application-desktop/windows/ChargingBatteryWindow.cpp @@ -8,7 +8,6 @@ #include #include #include -#include namespace gui { diff --git a/module-apps/application-desktop/windows/DeadBatteryWindow.cpp b/module-apps/application-desktop/windows/DeadBatteryWindow.cpp index 8de244b0e693279c313d4250d9e88963f75ae4d3..4552ca34db094be57d5c77d0544bbd040901aa18 100644 --- a/module-apps/application-desktop/windows/DeadBatteryWindow.cpp +++ b/module-apps/application-desktop/windows/DeadBatteryWindow.cpp @@ -9,7 +9,6 @@ #include #include #include -#include namespace gui { diff --git a/module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp b/module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp index 5f52642b38ec4c8f400c697a4fa5a9278b7914f8..567da6184d503f9862a5f1ea67f2c23cd13529c7 100644 --- a/module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp +++ b/module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp @@ -7,7 +7,6 @@ #include #include -#include using namespace gui; diff --git a/module-apps/application-desktop/windows/MmiPullWindow.cpp b/module-apps/application-desktop/windows/MmiPullWindow.cpp index f4ca9f197ce6aa6c7d7328131ed581813641f2e7..0f798fa680dcb9f39f73b146732002477c68c3d5 100644 --- a/module-apps/application-desktop/windows/MmiPullWindow.cpp +++ b/module-apps/application-desktop/windows/MmiPullWindow.cpp @@ -7,7 +7,6 @@ #include #include -#include #include diff --git a/module-apps/application-desktop/windows/MmiPushWindow.cpp b/module-apps/application-desktop/windows/MmiPushWindow.cpp index a31a55d3f6dd65d6813f4c7eea448281944a162a..ce85b85730bfc7ca122655cf78834a84578a1334 100644 --- a/module-apps/application-desktop/windows/MmiPushWindow.cpp +++ b/module-apps/application-desktop/windows/MmiPushWindow.cpp @@ -6,8 +6,8 @@ #include #include +#include #include -#include using namespace gui; diff --git a/module-apps/application-messages/windows/MessagesMainWindow.cpp b/module-apps/application-messages/windows/MessagesMainWindow.cpp index c82dcf8fe1bcbeb6183a8caa5533befc9d3b0f11..fda0e3320277550633e48011e98a630ee9dc5912 100644 --- a/module-apps/application-messages/windows/MessagesMainWindow.cpp +++ b/module-apps/application-messages/windows/MessagesMainWindow.cpp @@ -15,7 +15,6 @@ #include #include #include -#include #include #include #include diff --git a/module-apps/application-onboarding/ApplicationOnBoarding.cpp b/module-apps/application-onboarding/ApplicationOnBoarding.cpp index 3811d3d6d8f70af96f6ce5e1e617c8930ed82fbd..1c893acc748ed65d68d0e1a18d947621c7d792d9 100644 --- a/module-apps/application-onboarding/ApplicationOnBoarding.cpp +++ b/module-apps/application-onboarding/ApplicationOnBoarding.cpp @@ -17,8 +17,10 @@ #include "windows/OnBoardingChangeDateAndTimeWindow.hpp" #include +#include #include -#include +#include +#include namespace app { @@ -102,8 +104,7 @@ namespace app void ApplicationOnBoarding::finalizeOnBoarding() { - bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); } sys::ReturnCodes ApplicationOnBoarding::DeinitHandler() diff --git a/module-apps/application-settings/ApplicationSettings.cpp b/module-apps/application-settings/ApplicationSettings.cpp index 4052b39f910e6a0c686c76a2cc2e2302d88f3b3f..b7d999b04785caf6551c37193e83754d2114fc19 100644 --- a/module-apps/application-settings/ApplicationSettings.cpp +++ b/module-apps/application-settings/ApplicationSettings.cpp @@ -63,8 +63,8 @@ #include #include +#include #include -#include #include #include #include @@ -703,8 +703,7 @@ namespace app void ApplicationSettings::getAutoLockTime() { - bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); } auto ApplicationSettings::getCurrentPhoneMode() const noexcept -> sys::phone_modes::PhoneMode @@ -714,8 +713,7 @@ namespace app void ApplicationSettings::setAutoLockTime(std::chrono::seconds lockTime) { - bus.sendUnicast(std::make_shared(lockTime), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(lockTime), service::name::appmgr); } void ApplicationSettings::switchToAllDevicesViaBtErrorPrompt(std::shared_ptr msg, diff --git a/module-apps/apps-common/Application.cpp b/module-apps/apps-common/Application.cpp index b5076eceb3456b461841b54acd669a31d2a2ac6e..804746b4c0200da313f4fb7ade6554afbe4b7b0b 100644 --- a/module-apps/apps-common/Application.cpp +++ b/module-apps/apps-common/Application.cpp @@ -36,6 +36,7 @@ #include #include #include +#include #include #include // for GetOutputVolume diff --git a/module-apps/apps-common/locks/handlers/PhoneLockSubject.cpp b/module-apps/apps-common/locks/handlers/PhoneLockSubject.cpp index 239e528c2fcc658f9065878bdb7cef1c45de0afe..dd29986b573498fc3f5de166b54e9ceb0de4371b 100644 --- a/module-apps/apps-common/locks/handlers/PhoneLockSubject.cpp +++ b/module-apps/apps-common/locks/handlers/PhoneLockSubject.cpp @@ -3,7 +3,7 @@ #include "PhoneLockSubject.hpp" -#include +#include #include namespace locks @@ -17,42 +17,41 @@ namespace locks void PhoneLockSubject::unlock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::lock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::enablePhoneLock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::disablePhoneLock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::changePhoneLock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::setPhoneLock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::skipSetPhoneLock() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void PhoneLockSubject::verifyInput(LockInput inputData) { - owner->bus.sendUnicast(std::make_shared(inputData), - app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(inputData), service::name::appmgr); } } // namespace locks diff --git a/module-apps/apps-common/locks/handlers/SimLockSubject.cpp b/module-apps/apps-common/locks/handlers/SimLockSubject.cpp index d9b3dcb0654e5964c3fa2cee985c9105a09bf7e2..22f8d8add7cbce933a7ab735498d8806b59b6214 100644 --- a/module-apps/apps-common/locks/handlers/SimLockSubject.cpp +++ b/module-apps/apps-common/locks/handlers/SimLockSubject.cpp @@ -3,8 +3,9 @@ #include "SimLockSubject.hpp" -#include -#include +#include +#include +#include namespace locks { @@ -17,27 +18,26 @@ namespace locks void SimLockSubject::setSim(cellular::api::SimSlot simSlot) { - owner->bus.sendUnicast(std::make_shared(simSlot), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(simSlot), service::name::appmgr); } void SimLockSubject::changeSimPin() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void SimLockSubject::enableSimPin() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void SimLockSubject::disableSimPin() { - owner->bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(), service::name::appmgr); } void SimLockSubject::verifyInput(LockInput inputData) { - owner->bus.sendUnicast(std::make_shared(inputData), - app::manager::ApplicationManager::ServiceName); + owner->bus.sendUnicast(std::make_shared(inputData), service::name::appmgr); } } // namespace locks diff --git a/module-apps/apps-common/windows/Dialog.cpp b/module-apps/apps-common/windows/Dialog.cpp index b12d6fe8182c039ac09cc101d9be4035050bf4d5..0e7e4a82798b38428736136614b984f54b1c83ef 100644 --- a/module-apps/apps-common/windows/Dialog.cpp +++ b/module-apps/apps-common/windows/Dialog.cpp @@ -3,9 +3,9 @@ #include "Dialog.hpp" #include "DialogMetadataMessage.hpp" -#include #include #include +#include using namespace gui; diff --git a/module-apps/apps-common/windows/OptionWindow.cpp b/module-apps/apps-common/windows/OptionWindow.cpp index 9baae55472d463e5d91b1ad1a987d9b9669a7d5d..33b9eefad82537ffca9bae4bbb03ff460e603a4c 100644 --- a/module-apps/apps-common/windows/OptionWindow.cpp +++ b/module-apps/apps-common/windows/OptionWindow.cpp @@ -5,7 +5,6 @@ #include "Label.hpp" #include #include -#include #include #include #include diff --git a/module-services/service-antenna/ServiceAntenna.cpp b/module-services/service-antenna/ServiceAntenna.cpp index 5329adb851904e40726d7af9a8898104e62b9c8c..513d14de61deb5afc0f58f131d9bbc02e2226d13 100644 --- a/module-services/service-antenna/ServiceAntenna.cpp +++ b/module-services/service-antenna/ServiceAntenna.cpp @@ -12,7 +12,6 @@ #include #include #include -#include #include #include #include diff --git a/module-services/service-appmgr/CMakeLists.txt b/module-services/service-appmgr/CMakeLists.txt index a5ea972363943a1a3fafe64f8b099fca61285aaa..545e65ff10381292d9795875574ad7c464af9179 100644 --- a/module-services/service-appmgr/CMakeLists.txt +++ b/module-services/service-appmgr/CMakeLists.txt @@ -25,13 +25,14 @@ target_sources(service-appmgr messages/SwitchRequest.cpp model/ActionsRegistry.cpp model/ApplicationHandle.cpp - model/ApplicationManager.cpp + model/ApplicationManagerCommon.cpp model/ApplicationStack.cpp model/ApplicationsRegistry.cpp model/OnActionPolicy.cpp PUBLIC include/service-appmgr/Actions.hpp include/service-appmgr/ApplicationManifest.hpp + include/service-appmgr/Constants.hpp include/service-appmgr/Controller.hpp include/service-appmgr/StartupType.hpp include/service-appmgr/data/CallActionsParams.hpp @@ -61,7 +62,7 @@ target_sources(service-appmgr include/service-appmgr/messages/UserPowerDownRequest.hpp include/service-appmgr/model/ActionsRegistry.hpp include/service-appmgr/model/ApplicationHandle.hpp - include/service-appmgr/model/ApplicationManager.hpp + include/service-appmgr/model/ApplicationManagerCommon.hpp include/service-appmgr/model/ApplicationStack.hpp include/service-appmgr/model/ApplicationsRegistry.hpp include/service-appmgr/model/OnActionPolicy.hpp diff --git a/module-services/service-appmgr/Controller.cpp b/module-services/service-appmgr/Controller.cpp index 10e5afa684efec73b83c657512f45b2b92add2af..5fba5dff572d6151942828ddfa10d1363abe1b5d 100644 --- a/module-services/service-appmgr/Controller.cpp +++ b/module-services/service-appmgr/Controller.cpp @@ -3,11 +3,11 @@ #include "Controller.hpp" -#include "ApplicationManager.hpp" #include "FinishRequest.hpp" #include "GetAllNotificationsRequest.hpp" #include +#include #include @@ -28,13 +28,13 @@ namespace app::manager StartInBackground startInBackground) -> bool { auto msg = std::make_shared(sender->GetName(), status, startInBackground); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::finish(sys::Service *sender) -> bool { auto msg = std::make_shared(sender->GetName()); - return sender->bus.sendUnicast(std::move(msg), ApplicationManager::ServiceName); + return sender->bus.sendUnicast(std::move(msg), service::name::appmgr); } auto Controller::sendAction(sys::Service *sender, @@ -44,61 +44,61 @@ namespace app::manager { setOnSwitchBehaviour(data, onSwitchBehaviour); auto msg = std::make_shared(sender->GetName(), actionId, std::move(data)); - return sender->bus.sendUnicast(std::move(msg), ApplicationManager::ServiceName); + return sender->bus.sendUnicast(std::move(msg), service::name::appmgr); } auto Controller::switchBack(sys::Service *sender, std::unique_ptr msg) -> bool { std::shared_ptr switchMsg = msg ? std::move(msg) : std::make_shared(sender->GetName()); - return sender->bus.sendUnicast(switchMsg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(switchMsg, service::name::appmgr); } auto Controller::confirmSwitch(sys::Service *sender) -> bool { auto msg = std::make_shared(sender->GetName()); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::closeApplication(sys::Service *sender, const ApplicationName &name) -> bool { auto msg = std::make_shared(sender->GetName(), name); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::confirmClose(sys::Service *sender) -> bool { auto msg = std::make_shared(sender->GetName()); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::changeDisplayLanguage(sys::Service *sender, const Language &language) -> bool { auto msg = std::make_shared(sender->GetName(), language); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::changeInputLanguage(sys::Service *sender, const Language &language) -> bool { auto msg = std::make_shared(sender->GetName(), language); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::preventBlockingDevice(sys::Service *sender) -> bool { auto msg = std::make_shared(sender->GetName()); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::changePowerSaveMode(sys::Service *sender) -> bool { auto msg = std::make_shared(sender->GetName()); - return sender->bus.sendUnicast(msg, ApplicationManager::ServiceName); + return sender->bus.sendUnicast(msg, service::name::appmgr); } auto Controller::requestNotifications(sys::Service *sender) -> bool { auto msg = std::make_shared(); - return sender->bus.sendUnicast(std::move(msg), ApplicationManager::ServiceName); + return sender->bus.sendUnicast(std::move(msg), service::name::appmgr); } } // namespace app::manager diff --git a/module-services/service-appmgr/include/service-appmgr/Constants.hpp b/module-services/service-appmgr/include/service-appmgr/Constants.hpp new file mode 100644 index 0000000000000000000000000000000000000000..c2cabbc859dfb79106d619332a233746f2852a40 --- /dev/null +++ b/module-services/service-appmgr/include/service-appmgr/Constants.hpp @@ -0,0 +1,9 @@ +// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#pragma once + +namespace service::name +{ + inline constexpr auto appmgr = "ApplicationManager"; +}; diff --git a/module-services/service-appmgr/include/service-appmgr/Controller.hpp b/module-services/service-appmgr/include/service-appmgr/Controller.hpp index 53e78c699e9952c6231c9c4fae7356cfdcc789fa..b2394b096d76d6f4a3c59f6d944d33eaf5c6e1be 100644 --- a/module-services/service-appmgr/include/service-appmgr/Controller.hpp +++ b/module-services/service-appmgr/include/service-appmgr/Controller.hpp @@ -5,7 +5,6 @@ #include #include -#include #include #include diff --git a/module-services/service-appmgr/include/service-appmgr/model/ActionsRegistry.hpp b/module-services/service-appmgr/include/service-appmgr/model/ActionsRegistry.hpp index ca8662e9359555eb6a693620973eef1730127116..84cbc9239ef46e085f0b85faa0e8e8cd9846144c 100644 --- a/module-services/service-appmgr/include/service-appmgr/model/ActionsRegistry.hpp +++ b/module-services/service-appmgr/include/service-appmgr/model/ActionsRegistry.hpp @@ -42,7 +42,8 @@ namespace app::manager { Accepted, Skipped, - Dropped + Dropped, + NotHandled }; class ActionsRegistry diff --git a/module-services/service-appmgr/include/service-appmgr/model/ApplicationManager.hpp b/module-services/service-appmgr/include/service-appmgr/model/ApplicationManagerCommon.hpp similarity index 66% rename from module-services/service-appmgr/include/service-appmgr/model/ApplicationManager.hpp rename to module-services/service-appmgr/include/service-appmgr/model/ApplicationManagerCommon.hpp index 09dae04d66c9190f547fd3e6cc83b3cbdfb1ff9a..314ce54c5f0468c3f6f85fd39621c0c383baac16 100644 --- a/module-services/service-appmgr/include/service-appmgr/model/ApplicationManager.hpp +++ b/module-services/service-appmgr/include/service-appmgr/model/ApplicationManagerCommon.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md #pragma once @@ -96,14 +96,12 @@ namespace app::manager State state = State::Running; }; - class ApplicationManager : public sys::Service, private ApplicationManagerBase + class ApplicationManagerCommon : public sys::Service, protected ApplicationManagerBase { public: - static constexpr auto ServiceName = "ApplicationManager"; - - ApplicationManager(const ApplicationName &serviceName, - std::vector> &&launchers, - const ApplicationName &_rootApplicationName); + ApplicationManagerCommon(const ApplicationName &serviceName, + std::vector> &&launchers, + const ApplicationName &_rootApplicationName); auto InitHandler() -> sys::ReturnCodes override; auto DeinitHandler() -> sys::ReturnCodes override; @@ -111,9 +109,23 @@ namespace app::manager auto SwitchPowerModeHandler(const sys::ServicePowerMode mode) -> sys::ReturnCodes override; auto DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp) -> sys::MessagePointer override; + protected: + virtual auto handleAction(ActionEntry &action) -> ActionProcessStatus; + auto handleMessageAsAction(sys::Message *request) -> std::shared_ptr; + virtual auto startApplication(ApplicationHandle &app) -> bool; + virtual auto resolveHomeWindow() -> std::string; + virtual auto resolveHomeApplication() -> std::string + { + return rootApplicationName; + } + auto checkOnBoarding() -> bool; + virtual void registerMessageHandlers(); + + ApplicationName rootApplicationName; + ActionsRegistry actionsRegistry; + std::shared_ptr settings; + private: - auto startApplication(ApplicationHandle &app) -> bool; - void startBackgroundApplications(); void rebuildActiveApplications(); void suspendSystemServices(); void closeNoLongerNeededApplications(); @@ -122,20 +134,11 @@ namespace app::manager void closeApplication(ApplicationHandle *application); // Message handlers - void registerMessageHandlers(); - auto handleAction(ActionEntry &action) -> ActionProcessStatus; void handleActionRequest(ActionRequest *actionMsg); auto handleHomeAction(ActionEntry &action) -> ActionProcessStatus; - auto resolveHomeWindow() -> std::string; auto handleOnBoardingFinalize() -> sys::MessagePointer; - auto checkOnBoarding() -> bool; - auto resolveHomeApplication() -> std::string; auto handleLaunchAction(ActionEntry &action) -> ActionProcessStatus; auto handleActionOnFocusedApp(ActionEntry &action) -> ActionProcessStatus; - auto handlePhoneModeChangedAction(ActionEntry &action) -> ActionProcessStatus; - void handlePhoneModeChanged(sys::phone_modes::PhoneMode phoneMode); - void handleTetheringChanged(sys::phone_modes::Tethering tethering); - void changePhoneMode(sys::phone_modes::PhoneMode phoneMode, const ApplicationHandle *app); auto handleCustomAction(ActionEntry &action) -> ActionProcessStatus; auto handleCustomActionOnBackgroundApp(ApplicationHandle *app, ActionEntry &action) -> ActionProcessStatus; auto handleSwitchApplication(SwitchRequest *msg, bool closeCurrentlyFocusedApp = true) -> bool; @@ -145,15 +148,11 @@ namespace app::manager auto handleInitApplication(ApplicationInitialised *msg) -> bool; auto handleDisplayLanguageChange(DisplayLanguageChangeRequest *msg) -> bool; auto handleInputLanguageChange(InputLanguageChangeRequest *msg) -> bool; - auto handleDBResponse(db::QueryResponse *msg) -> bool; auto handlePowerSavingModeInit() -> bool; - auto handleMessageAsAction(sys::Message *request) -> std::shared_ptr; - auto handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer; + virtual auto handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer; /// handles dom request by passing this request to application which should provide the dom auto handleDOMRequest(sys::Message *request) -> std::shared_ptr; void handleStart(StartAllowedMessage *msg); - auto handleAutoLockGetRequest(GetAutoLockTimeoutRequest *request) -> std::shared_ptr; - auto handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request) -> std::shared_ptr; void requestApplicationClose(ApplicationHandle &app, bool isCloseable); void onApplicationSwitch(ApplicationHandle &nextApp, @@ -165,49 +164,10 @@ namespace app::manager auto onSwitchConfirmed(ApplicationHandle &app) -> bool; void onLaunchFinished(ApplicationHandle &app); auto onCloseConfirmed(ApplicationHandle &app) -> bool; - /// @brief method is called on auto-locking timer tick event (blockTimer) - /// @detailed It sends AutoLock action to ApplicationDesktop to lock the screen. - /// @note AutoLock action is sent only if following conditions are met: - /// - tethering is off - /// - focused application is not preventing AutoLock - void onPhoneLocked(); - ApplicationName rootApplicationName; - ActionsRegistry actionsRegistry; OnActionPolicy actionPolicy; - sys::TimerHandle autoLockTimer; //< auto-lock timer to count time from last user's activity. - // If it reaches time defined in settings database application - // manager is sending signal to Application Desktop in order to - // lock screen. - std::shared_ptr settings; - std::shared_ptr phoneModeObserver; - - locks::PhoneLockHandler phoneLockHandler; - locks::SimLockHandler simLockHandler; - - notifications::NotificationsConfiguration notificationsConfig; - notifications::NotificationsHandler notificationsHandler; - notifications::NotificationProvider notificationProvider; - void displayLanguageChanged(std::string value); - void lockTimeChanged(std::string value); void inputLanguageChanged(std::string value); - - void processKeypadBacklightState(bsp::keypad_backlight::State keypadLightState); }; } // namespace app::manager - -namespace sys -{ - template <> struct ManifestTraits - { - static auto GetManifest() -> ServiceManifest - { - ServiceManifest manifest; - manifest.name = app::manager::ApplicationManager::ServiceName; - manifest.dependencies = {service::name::db, service::name::gui, service::name::eink}; - return manifest; - } - }; -} // namespace sys diff --git a/module-services/service-appmgr/model/ActionsRegistry.cpp b/module-services/service-appmgr/model/ActionsRegistry.cpp index 3e237e216964bd17da822eefa53cd2f65fd9e57a..55757d1c018427dc684973fa0668ec4f3d591169 100644 --- a/module-services/service-appmgr/model/ActionsRegistry.cpp +++ b/module-services/service-appmgr/model/ActionsRegistry.cpp @@ -84,6 +84,8 @@ namespace app::manager it = actions.erase(it); break; } + case ActionProcessStatus::NotHandled: + [[fallthrough]]; case ActionProcessStatus::Skipped: // Skip the action and check the next one. ++it; diff --git a/module-services/service-appmgr/model/ApplicationManager.cpp b/module-services/service-appmgr/model/ApplicationManagerCommon.cpp similarity index 53% rename from module-services/service-appmgr/model/ApplicationManager.cpp rename to module-services/service-appmgr/model/ApplicationManagerCommon.cpp index 41269a509847768bb9c10a6b1b712db2d5fdbf63..e20117814140e8e2eeac50213b1df55c026e0fad 100644 --- a/module-services/service-appmgr/model/ApplicationManager.cpp +++ b/module-services/service-appmgr/model/ApplicationManagerCommon.cpp @@ -1,7 +1,7 @@ // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md -#include "ApplicationManager.hpp" +#include "ApplicationManagerCommon.hpp" #include "ApplicationStatus.hpp" #include "AutoLockRequests.hpp" #include "Controller.hpp" @@ -31,6 +31,7 @@ #include #include #include +#include #include #include #include @@ -49,7 +50,6 @@ namespace app::manager namespace { constexpr auto ApplicationManagerStackDepth = 3072; - constexpr auto autoLockTimerName = "AutoLockTimer"; } // namespace ApplicationManagerBase::ApplicationManagerBase(std::vector> &&launchers) @@ -116,50 +116,25 @@ namespace app::manager return runningApps; } - ApplicationManager::ApplicationManager(const ApplicationName &serviceName, - std::vector> &&launchers, - const ApplicationName &_rootApplicationName) + ApplicationManagerCommon::ApplicationManagerCommon( + const ApplicationName &serviceName, + std::vector> &&launchers, + const ApplicationName &_rootApplicationName) : Service{serviceName, {}, ApplicationManagerStackDepth}, ApplicationManagerBase(std::move(launchers)), rootApplicationName{_rootApplicationName}, actionsRegistry{[this](ActionEntry &action) { return handleAction(action); }}, - settings(std::make_shared()), - phoneModeObserver(std::make_shared()), - phoneLockHandler(locks::PhoneLockHandler(this, settings)), - simLockHandler(this), notificationsConfig{phoneModeObserver, settings, phoneLockHandler}, - notificationsHandler{this, notificationsConfig}, notificationProvider{this, notificationsConfig} + settings(std::make_shared()) { - autoLockTimer = sys::TimerFactory::createSingleShotTimer( - this, autoLockTimerName, sys::timer::InfiniteTimeout, [this](sys::Timer &) { onPhoneLocked(); }); - bus.channels.push_back(sys::BusChannel::PhoneModeChanges); bus.channels.push_back(sys::BusChannel::ServiceAudioNotifications); bus.channels.push_back(sys::BusChannel::ServiceDBNotifications); - bus.channels.push_back(sys::BusChannel::PhoneLockChanges); - bus.channels.push_back(sys::BusChannel::ServiceCellularNotifications); - registerMessageHandlers(); } - sys::ReturnCodes ApplicationManager::InitHandler() + sys::ReturnCodes ApplicationManagerCommon::InitHandler() { settings->init(service::ServiceProxy(shared_from_this())); utils::setDisplayLanguage( settings->getValue(settings::SystemProperties::displayLanguage, settings::SettingsScope::Global)); - phoneLockHandler.enablePhoneLock((utils::getNumericValue( - settings->getValue(settings::SystemProperties::lockScreenPasscodeIsOn, settings::SettingsScope::Global)))); - - phoneLockHandler.setPhoneLockHash( - settings->getValue(settings::SystemProperties::lockPassHash, settings::SettingsScope::Global)); - - settings->registerValueChange( - settings::SystemProperties::lockScreenPasscodeIsOn, - [this](const std::string &value) { phoneLockHandler.enablePhoneLock(utils::getNumericValue(value)); }, - settings::SettingsScope::Global); - - settings->registerValueChange( - settings::SystemProperties::lockPassHash, - [this](const std::string &value) { phoneLockHandler.setPhoneLockHash(value); }, - settings::SettingsScope::Global); - settings->registerValueChange( settings::SystemProperties::displayLanguage, [this](std::string value) { displayLanguageChanged(std::move(value)); }, @@ -168,26 +143,13 @@ namespace app::manager settings::SystemProperties::inputLanguage, [this](std::string value) { inputLanguageChanged(std::move(value)); }, settings::SettingsScope::Global); - settings->registerValueChange( - settings::SystemProperties::autoLockTimeInSec, - [this](std::string value) { lockTimeChanged(std::move(value)); }, - settings::SettingsScope::Global); - settings->registerValueChange( - ::settings::KeypadLight::state, - [this](const std::string &value) { - const auto keypadLightState = - static_cast(utils::getNumericValue(value)); - processKeypadBacklightState(keypadLightState); - }, - ::settings::SettingsScope::Global); - - startBackgroundApplications(); + bus.sendUnicast(std::make_unique(), service::name::system_manager); return sys::ReturnCodes::Success; } - void ApplicationManager::handleStart(StartAllowedMessage *msg) + void ApplicationManagerCommon::handleStart(StartAllowedMessage *msg) { switch (msg->getStartupType()) { case StartupType::Regular: @@ -196,41 +158,33 @@ namespace app::manager } break; case StartupType::LowBattery: - handleSwitchApplication( - std::make_unique(ServiceName, app::name_desktop, window::name::dead_battery, nullptr) - .get()); + handleSwitchApplication(std::make_unique( + service::name::appmgr, app::name_desktop, window::name::dead_battery, nullptr) + .get()); break; case StartupType::LowBatteryCharging: handleSwitchApplication( - std::make_unique(ServiceName, app::name_desktop, window::name::charging_battery, nullptr) + std::make_unique( + service::name::appmgr, app::name_desktop, window::name::charging_battery, nullptr) .get()); break; } } - void ApplicationManager::suspendSystemServices() + void ApplicationManagerCommon::suspendSystemServices() { sys::SystemManager::SuspendService(service::name::gui, this); sys::SystemManager::SuspendService(service::name::eink, this); } - void ApplicationManager::startBackgroundApplications() - { - for (const auto &name : std::vector{app::special_input}) { - if (auto app = getApplication(name); app != nullptr) { - app->runInBackground(phoneModeObserver->getCurrentPhoneMode(), this); - } - } - } - - sys::ReturnCodes ApplicationManager::DeinitHandler() + sys::ReturnCodes ApplicationManagerCommon::DeinitHandler() { settings->deinit(); closeApplications(); return sys::ReturnCodes::Success; } - auto ApplicationManager::ProcessCloseReason(sys::CloseReason closeReason) -> void + auto ApplicationManagerCommon::ProcessCloseReason(sys::CloseReason closeReason) -> void { ActionRequest act = ActionRequest{this->GetName(), app::manager::actions::DisplayLogoAtExit, nullptr}; switch (closeReason) { @@ -248,26 +202,15 @@ namespace app::manager sendCloseReadyMessage(this); } - auto ApplicationManager::DataReceivedHandler([[maybe_unused]] sys::DataMessage *msgl, - [[maybe_unused]] sys::ResponseMessage *resp) -> sys::MessagePointer + auto ApplicationManagerCommon::DataReceivedHandler([[maybe_unused]] sys::DataMessage *msgl, + [[maybe_unused]] sys::ResponseMessage *resp) + -> sys::MessagePointer { return std::make_shared(); } - void ApplicationManager::registerMessageHandlers() + void ApplicationManagerCommon::registerMessageHandlers() { - phoneModeObserver->connect(this); - phoneModeObserver->subscribe([this](sys::phone_modes::PhoneMode phoneMode) { - handlePhoneModeChanged(phoneMode); - actionsRegistry.enqueue( - ActionEntry{actions::ShowPopup, std::make_unique(phoneMode)}); - }); - - phoneModeObserver->subscribe( - [this](sys::phone_modes::Tethering tethering) { handleTetheringChanged(tethering); }); - - notificationsHandler.registerMessageHandlers(); - connect(typeid(StartAllowedMessage), [this](sys::Message *request) { auto msg = static_cast(request); handleStart(msg); @@ -282,12 +225,6 @@ namespace app::manager handlePowerSavingModeInit(); return std::make_shared(); }); - connect(typeid(PreventBlockingRequest), [this]([[maybe_unused]] sys::Message *msg) { - if (!phoneLockHandler.isPhoneLocked()) { - autoLockTimer.start(); - } - return std::make_shared(); - }); connect(typeid(SwitchRequest), [this](sys::Message *request) { auto msg = static_cast(request); handleSwitchApplication(msg); @@ -350,176 +287,6 @@ namespace app::manager connect(typeid(GetCurrentDisplayLanguageRequest), [&](sys::Message *request) { return std::make_shared(utils::getDisplayLanguage()); }); - connect(typeid(GetAllNotificationsRequest), [&](sys::Message *request) { - notificationProvider.requestNotSeenNotifications(); - notificationProvider.send(); - return sys::msgHandled(); - }); - connect(typeid(db::NotificationMessage), [&](sys::Message *msg) { - auto msgl = static_cast(msg); - notificationProvider.handle(msgl); - return sys::msgHandled(); - }); - connect(typeid(db::QueryResponse), [&](sys::Message *msg) { - auto response = static_cast(msg); - handleDBResponse(response); - return sys::msgHandled(); - }); - - // PhoneLock connects - connect(typeid(locks::LockPhone), - [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleLockRequest(); }); - connect(typeid(locks::UnlockPhone), - [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleUnlockRequest(); }); - connect(typeid(locks::CancelUnlockPhone), [&](sys::Message *request) -> sys::MessagePointer { - return phoneLockHandler.handleUnlockCancelRequest(); - }); - connect(typeid(locks::UnLockPhoneInput), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - return phoneLockHandler.handlePhoneLockInput(data->getInputData()); - }); - connect(typeid(locks::EnablePhoneLock), - [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleEnablePhoneLock(); }); - connect(typeid(locks::DisablePhoneLock), [&](sys::Message *request) -> sys::MessagePointer { - return phoneLockHandler.handleDisablePhoneLock(); - }); - connect(typeid(locks::UnlockedPhone), [&](sys::Message *request) -> sys::MessagePointer { - autoLockTimer.start(); - return simLockHandler.releaseSimUnlockBlockOnLockedPhone(); - }); - connect(typeid(locks::ChangePhoneLock), - [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleChangePhoneLock(); }); - connect(typeid(locks::SetPhoneLock), - [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleSetPhoneLock(); }); - connect(typeid(locks::SkipSetPhoneLock), [&](sys::Message *request) -> sys::MessagePointer { - return phoneLockHandler.handleSkipSetPhoneLock(); - }); - connect(typeid(GetAutoLockTimeoutRequest), [&](sys::Message *request) -> sys::MessagePointer { - auto req = static_cast(request); - return handleAutoLockGetRequest(req); - }); - connect(typeid(SetAutoLockTimeoutRequest), [&](sys::Message *request) -> sys::MessagePointer { - auto req = static_cast(request); - return handleAutoLockSetRequest(req); - }); - connect(typeid(locks::ExternalUnLockPhone), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - return phoneLockHandler.handleExternalUnlockRequest(data->getInputData()); - }); - connect(typeid(locks::ExternalPhoneLockAvailabilityChange), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - return phoneLockHandler.handleExternalAvailabilityChange(data->getAvailability()); - }); - - // SimLock connects - connect(typeid(cellular::msg::notification::SimNeedPin), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (phoneLockHandler.isPhoneLocked()) { - simLockHandler.setSimUnlockBlockOnLockedPhone(); - } - return simLockHandler.handleSimPinRequest(data->attempts); - }); - connect(typeid(cellular::msg::request::sim::PinUnlock::Response), - [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (data->retCode) { - return simLockHandler.handleSimUnlockedMessage(); - } - return sys::msgNotHandled(); - }); - connect(typeid(locks::UnLockSimInput), [&](sys::Message *request) -> sys::MessagePointer { - auto msg = static_cast(request); - return simLockHandler.verifySimLockInput(msg->getInputData()); - }); - connect(typeid(cellular::msg::notification::SimNeedPuk), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (phoneLockHandler.isPhoneLocked()) { - simLockHandler.setSimUnlockBlockOnLockedPhone(); - } - return simLockHandler.handleSimPukRequest(data->attempts); - }); - connect(typeid(cellular::msg::request::sim::UnblockWithPuk::Response), - [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (data->retCode) { - return simLockHandler.handleSimUnlockedMessage(); - } - return sys::msgNotHandled(); - }); - connect(typeid(locks::ChangeSimPin), [&](sys::Message *request) -> sys::MessagePointer { - return simLockHandler.handleSimPinChangeRequest(); - }); - connect(typeid(cellular::msg::request::sim::ChangePin::Response), - [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (data->retCode) { - return simLockHandler.handleSimPinChangedMessage(); - } - else { - return simLockHandler.handleSimPinChangeFailedRequest(); - } - }); - connect(typeid(locks::EnableSimPin), - [&](sys::Message *request) -> sys::MessagePointer { return simLockHandler.handleSimEnableRequest(); }); - connect(typeid(locks::DisableSimPin), - [&](sys::Message *request) -> sys::MessagePointer { return simLockHandler.handleSimDisableRequest(); }); - connect(typeid(cellular::msg::request::sim::SetPinLock::Response), - [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (data->retCode) { - return simLockHandler.handleSimAvailabilityMessage(); - } - else { - if (data->lock == cellular::api::SimLockState::Enabled) { - return simLockHandler.handleSimEnableRequest(); - } - else { - return simLockHandler.handleSimDisableRequest(); - } - } - }); - connect(typeid(cellular::msg::notification::SimBlocked), [&](sys::Message *request) -> sys::MessagePointer { - if (phoneLockHandler.isPhoneLocked()) { - simLockHandler.setSimUnlockBlockOnLockedPhone(); - } - return simLockHandler.handleSimBlockedRequest(); - }); - connect(typeid(cellular::msg::notification::UnhandledCME), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (phoneLockHandler.isPhoneLocked()) { - simLockHandler.setSimUnlockBlockOnLockedPhone(); - } - return simLockHandler.handleCMEErrorRequest(data->code); - }); - connect(typeid(locks::SetSim), [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - simLockHandler.setSim(data->getSimSlot()); - return sys::msgHandled(); - }); - connect(typeid(cellular::msg::request::sim::SetActiveSim::Response), - [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (data->retCode) { - settings->setValue(::settings::SystemProperties::activeSim, - utils::enumToString(Store::GSM::get()->selected), - ::settings::SettingsScope::Global); - return sys::msgHandled(); - } - return sys::msgNotHandled(); - }); - connect(typeid(cellular::msg::notification::SimReady), - [&](sys::Message *request) -> sys::MessagePointer { return simLockHandler.handleSimReadyMessage(); }); - connect(typeid(cellular::msg::notification::ModemStateChanged), - [&](sys::Message *request) -> sys::MessagePointer { - auto data = static_cast(request); - if (data->state == cellular::api::ModemState::Ready) { - simLockHandler.setSimReady(); - simLockHandler.getSettingsSimSelect( - settings->getValue(settings::SystemProperties::activeSim, settings::SettingsScope::Global)); - return sys::msgHandled(); - } - return sys::msgNotHandled(); - }); connect(typeid(onBoarding::FinalizeOnBoarding), [&](sys::Message *request) -> sys::MessagePointer { return handleOnBoardingFinalize(); }); @@ -530,26 +297,11 @@ namespace app::manager connect(typeid(app::manager::DOMRequest), [&](sys::Message *request) { return handleDOMRequest(request); }); auto convertibleToActionHandler = [this](sys::Message *request) { return handleMessageAsAction(request); }; - connect(typeid(CellularMMIResultMessage), convertibleToActionHandler); - connect(typeid(CellularMMIResponseMessage), convertibleToActionHandler); - connect(typeid(CellularMMIPushMessage), convertibleToActionHandler); - connect(typeid(CellularNoSimNotification), convertibleToActionHandler); - connect(typeid(CellularNotAnEmergencyNotification), convertibleToActionHandler); connect(typeid(sys::CriticalBatteryLevelNotification), convertibleToActionHandler); - connect(typeid(CellularSmsNoSimRequestMessage), convertibleToActionHandler); - connect(typeid(CellularSMSRejectedByOfflineNotification), convertibleToActionHandler); - connect(typeid(CellularCallRejectedByOfflineNotification), convertibleToActionHandler); - connect(typeid(sys::TetheringQuestionRequest), convertibleToActionHandler); - connect(typeid(sys::TetheringQuestionAbort), convertibleToActionHandler); - connect(typeid(sys::TetheringPhoneModeChangeProhibitedMessage), convertibleToActionHandler); connect(typeid(VolumeChanged), convertibleToActionHandler); - connect(typeid(CellularCallAbortedNotification), convertibleToActionHandler); - connect(typeid(CellularRingingMessage), convertibleToActionHandler); - connect(typeid(CellularCallActiveNotification), convertibleToActionHandler); - connect(typeid(CellularHangupCallMessage), convertibleToActionHandler); } - sys::ReturnCodes ApplicationManager::SwitchPowerModeHandler(const sys::ServicePowerMode mode) + sys::ReturnCodes ApplicationManagerCommon::SwitchPowerModeHandler(const sys::ServicePowerMode mode) { LOG_INFO("Power mode: %s", c_str(mode)); @@ -567,22 +319,19 @@ namespace app::manager return sys::ReturnCodes::Success; } - auto ApplicationManager::startApplication(ApplicationHandle &app) -> bool + auto ApplicationManagerCommon::startApplication(ApplicationHandle &app) -> bool { if (app.state() == ApplicationHandle::State::ACTIVE_BACKGROUND) { LOG_INFO("Switching focus to application [%s] (window [%s])", app.name().c_str(), app.switchWindow.c_str()); setState(State::AwaitingFocusConfirmation); app::Application::messageSwitchApplication( this, app.name(), app.switchWindow, std::move(app.switchData), StartupReason::Launch); + return true; } - else { - LOG_INFO("Starting application %s", app.name().c_str()); - app.run(phoneModeObserver->getCurrentPhoneMode(), this); - } - return true; + return false; } - auto ApplicationManager::closeApplications() -> bool + auto ApplicationManagerCommon::closeApplications() -> bool { for (const auto &app : getApplications()) { if (app->started()) { @@ -594,7 +343,7 @@ namespace app::manager return true; } - void ApplicationManager::closeNoLongerNeededApplications() + void ApplicationManagerCommon::closeNoLongerNeededApplications() { for (const auto &app : getApplications()) { if (app->started() && app->closeable() && !stack.contains(app->name())) { @@ -604,7 +353,7 @@ namespace app::manager } } - auto ApplicationManager::closeApplicationsOnUpdate() -> bool + auto ApplicationManagerCommon::closeApplicationsOnUpdate() -> bool { for (const auto &app : getApplications()) { if (app->started()) { @@ -621,7 +370,7 @@ namespace app::manager return true; } - void ApplicationManager::closeApplication(ApplicationHandle *application) + void ApplicationManagerCommon::closeApplication(ApplicationHandle *application) { if (application == nullptr) { return; @@ -636,13 +385,13 @@ namespace app::manager application->close(); } - auto ApplicationManager::handlePowerSavingModeInit() -> bool + auto ApplicationManagerCommon::handlePowerSavingModeInit() -> bool { LOG_INFO("Going to suspend mode"); return true; } - auto ApplicationManager::handleSwitchApplication(SwitchRequest *msg, bool closeCurrentlyFocusedApp) -> bool + auto ApplicationManagerCommon::handleSwitchApplication(SwitchRequest *msg, bool closeCurrentlyFocusedApp) -> bool { auto app = getApplication(msg->getName()); if (app == nullptr) { @@ -679,9 +428,9 @@ namespace app::manager return true; } - void ApplicationManager::onApplicationSwitch(ApplicationHandle &nextApp, - std::unique_ptr &&data, - std::string targetWindow) + void ApplicationManagerCommon::onApplicationSwitch(ApplicationHandle &nextApp, + std::unique_ptr &&data, + std::string targetWindow) { if (nextApp.name() == rootApplicationName) { stack.clear(); @@ -692,7 +441,7 @@ namespace app::manager nextApp.switchWindow = std::move(targetWindow); } - void ApplicationManager::requestApplicationClose(ApplicationHandle &app, bool isCloseable) + void ApplicationManagerCommon::requestApplicationClose(ApplicationHandle &app, bool isCloseable) { if (isCloseable) { LOG_INFO("Closing application %s", app.name().c_str()); @@ -706,32 +455,13 @@ namespace app::manager } } - void ApplicationManager::handleActionRequest(ActionRequest *actionMsg) + void ApplicationManagerCommon::handleActionRequest(ActionRequest *actionMsg) { ActionEntry entry{actionMsg->getAction(), std::move(actionMsg->getData())}; actionsRegistry.enqueue(std::move(entry)); } - void ApplicationManager::handlePhoneModeChanged(sys::phone_modes::PhoneMode phoneMode) - { - for (const auto app : getStackedApplications()) { - changePhoneMode(phoneMode, app); - } - } - - void ApplicationManager::changePhoneMode(sys::phone_modes::PhoneMode phoneMode, const ApplicationHandle *app) - { - ActionEntry action{actions::PhoneModeChanged, std::make_unique(phoneMode)}; - action.setTargetApplication(app->name()); - actionsRegistry.enqueue(std::move(action)); - } - - void ApplicationManager::handleTetheringChanged(sys::phone_modes::Tethering tethering) - { - notificationProvider.handle(tethering); - } - - ActionProcessStatus ApplicationManager::handleAction(ActionEntry &action) + ActionProcessStatus ApplicationManagerCommon::handleAction(ActionEntry &action) { switch (action.actionId) { case actions::Home: @@ -739,7 +469,7 @@ namespace app::manager case actions::Launch: return handleLaunchAction(action); case actions::PhoneModeChanged: - return handlePhoneModeChangedAction(action); + return ActionProcessStatus::NotHandled; case actions::ShowPopup: [[fallthrough]]; case actions::AbortPopup: @@ -751,42 +481,32 @@ namespace app::manager } } - auto ApplicationManager::handleHomeAction(ActionEntry &action) -> ActionProcessStatus + auto ApplicationManagerCommon::handleHomeAction(ActionEntry &action) -> ActionProcessStatus { action.setTargetApplication(resolveHomeApplication()); - SwitchRequest switchRequest(ServiceName, resolveHomeApplication(), resolveHomeWindow(), nullptr); + SwitchRequest switchRequest(service::name::appmgr, resolveHomeApplication(), resolveHomeWindow(), nullptr); return handleSwitchApplication(&switchRequest) ? ActionProcessStatus::Accepted : ActionProcessStatus::Dropped; } - auto ApplicationManager::resolveHomeWindow() -> std::string + auto ApplicationManagerCommon::resolveHomeWindow() -> std::string { - return phoneLockHandler.isPhoneLocked() ? gui::popup::window::phone_lock_window - : gui::name::window::main_window; + return gui::name::window::main_window; } - auto ApplicationManager::handleOnBoardingFinalize() -> sys::MessagePointer + auto ApplicationManagerCommon::handleOnBoardingFinalize() -> sys::MessagePointer { settings->setValue(settings::SystemProperties::onboardingDone, utils::to_string(true)); app::manager::Controller::sendAction(this, app::manager::actions::Home); return sys::msgHandled(); } - auto ApplicationManager::checkOnBoarding() -> bool + auto ApplicationManagerCommon::checkOnBoarding() -> bool { return not utils::getNumericValue(settings->getValue(settings::SystemProperties::onboardingDone)); } - auto ApplicationManager::resolveHomeApplication() -> std::string - { - if (checkOnBoarding()) { - phoneLockHandler.handleUnlockRequest(); - return app::name_onboarding; - } - return rootApplicationName; - } - - auto ApplicationManager::handleLaunchAction(ActionEntry &action) -> ActionProcessStatus + auto ApplicationManagerCommon::handleLaunchAction(ActionEntry &action) -> ActionProcessStatus { auto launchParams = static_cast(action.params.get()); auto targetApp = getApplication(launchParams->getTargetApplicationName()); @@ -796,27 +516,11 @@ namespace app::manager targetApp->startupReason = StartupReason::Launch; action.setTargetApplication(targetApp->name()); - SwitchRequest switchRequest(ServiceName, targetApp->name(), gui::name::window::main_window, nullptr); + SwitchRequest switchRequest(service::name::appmgr, targetApp->name(), gui::name::window::main_window, nullptr); return handleSwitchApplication(&switchRequest) ? ActionProcessStatus::Accepted : ActionProcessStatus::Dropped; } - auto ApplicationManager::handlePhoneModeChangedAction(ActionEntry &action) -> ActionProcessStatus - { - const auto &targetName = action.target; - auto targetApp = getApplication(targetName); - if (targetApp == nullptr || !targetApp->handles(action.actionId)) { - return ActionProcessStatus::Dropped; - } - - if (targetApp->state() == ApplicationHandle::State::ACTIVE_FORGROUND || - targetApp->state() == ApplicationHandle::State::ACTIVE_BACKGROUND) { - app::Application::requestAction(this, targetName, action.actionId, std::move(action.params)); - return ActionProcessStatus::Accepted; - } - return ActionProcessStatus::Skipped; - } - - auto ApplicationManager::handleActionOnFocusedApp(ActionEntry &action) -> ActionProcessStatus + auto ApplicationManagerCommon::handleActionOnFocusedApp(ActionEntry &action) -> ActionProcessStatus { auto targetApp = getFocusedApplication(); if (targetApp == nullptr) { @@ -828,7 +532,7 @@ namespace app::manager return ActionProcessStatus::Accepted; } - auto ApplicationManager::handleCustomAction(ActionEntry &action) -> ActionProcessStatus + auto ApplicationManagerCommon::handleCustomAction(ActionEntry &action) -> ActionProcessStatus { const auto actionHandlers = applications.findByAction(action.actionId); if (actionHandlers.empty()) { @@ -860,12 +564,12 @@ namespace app::manager const auto focusedAppClose = !(actionPolicy(action.actionId) == Reaction::KeepFocusedAppInBackground || (actionParams && actionParams->disableAppClose)); SwitchRequest switchRequest( - ServiceName, targetApp->name(), targetApp->switchWindow, std::move(targetApp->switchData)); + service::name::appmgr, targetApp->name(), targetApp->switchWindow, std::move(targetApp->switchData)); return handleSwitchApplication(&switchRequest, focusedAppClose) ? ActionProcessStatus::Accepted : ActionProcessStatus::Skipped; } - auto ApplicationManager::handleCustomActionOnBackgroundApp(ApplicationHandle *app, ActionEntry &action) + auto ApplicationManagerCommon::handleCustomActionOnBackgroundApp(ApplicationHandle *app, ActionEntry &action) -> ActionProcessStatus { if (const auto actionFlag = app->actionFlag(action.actionId); @@ -876,7 +580,7 @@ namespace app::manager return ActionProcessStatus::Dropped; } - auto ApplicationManager::handleSwitchBack(SwitchBackRequest *msg) -> bool + auto ApplicationManagerCommon::handleSwitchBack(SwitchBackRequest *msg) -> bool { auto previousApp = getPreviousApplication(); if (previousApp == nullptr) { @@ -912,14 +616,14 @@ namespace app::manager return true; } - void ApplicationManager::onApplicationSwitchToPrev(ApplicationHandle &previousApp, - std::unique_ptr &&data) + void ApplicationManagerCommon::onApplicationSwitchToPrev(ApplicationHandle &previousApp, + std::unique_ptr &&data) { stack.pop(); previousApp.switchData = std::move(data); } - auto ApplicationManager::handleInitApplication(ApplicationInitialised *msg) -> bool + auto ApplicationManagerCommon::handleInitApplication(ApplicationInitialised *msg) -> bool { auto app = getApplication(msg->getSenderName()); if (app == nullptr) { @@ -939,7 +643,7 @@ namespace app::manager return true; } - void ApplicationManager::onApplicationInitialised(ApplicationHandle &app, StartInBackground startInBackground) + void ApplicationManagerCommon::onApplicationInitialised(ApplicationHandle &app, StartInBackground startInBackground) { LOG_DEBUG("Application %s initialised successfully.", app.name().c_str()); @@ -963,13 +667,13 @@ namespace app::manager } } - void ApplicationManager::onApplicationInitFailure(ApplicationHandle &app) + void ApplicationManagerCommon::onApplicationInitFailure(ApplicationHandle &app) { LOG_ERROR("Failed to initialise %s: Application internal error.", app.name().c_str()); Controller::switchBack(this); } - auto ApplicationManager::handleDisplayLanguageChange(app::manager::DisplayLanguageChangeRequest *msg) -> bool + auto ApplicationManagerCommon::handleDisplayLanguageChange(app::manager::DisplayLanguageChangeRequest *msg) -> bool { const auto &requestedLanguage = msg->getLanguage(); @@ -983,7 +687,7 @@ namespace app::manager return true; } - auto ApplicationManager::handleInputLanguageChange(app::manager::InputLanguageChangeRequest *msg) -> bool + auto ApplicationManagerCommon::handleInputLanguageChange(app::manager::InputLanguageChangeRequest *msg) -> bool { const auto &requestedLanguage = msg->getLanguage(); @@ -996,17 +700,7 @@ namespace app::manager return true; } - auto ApplicationManager::handleDBResponse(db::QueryResponse *msg) -> bool - { - auto result = msg->getResult(); - if (auto response = dynamic_cast(result.get())) { - notificationProvider.handle(response); - return true; - } - return false; - } - - void ApplicationManager::rebuildActiveApplications() + void ApplicationManagerCommon::rebuildActiveApplications() { for (const auto &app : getApplications()) { if (app && app->valid()) { @@ -1018,7 +712,7 @@ namespace app::manager } } - auto ApplicationManager::handleSwitchConfirmation(SwitchConfirmation *msg) -> bool + auto ApplicationManagerCommon::handleSwitchConfirmation(SwitchConfirmation *msg) -> bool { auto senderApp = getApplication(msg->getSenderName()); if (senderApp == nullptr) { @@ -1030,7 +724,7 @@ namespace app::manager return onSwitchConfirmed(*senderApp); } - auto ApplicationManager::onSwitchConfirmed(ApplicationHandle &app) -> bool + auto ApplicationManagerCommon::onSwitchConfirmed(ApplicationHandle &app) -> bool { if (getState() == State::AwaitingFocusConfirmation || getState() == State::Running) { app.blockClosing = false; @@ -1054,7 +748,7 @@ namespace app::manager return false; } - void ApplicationManager::onLaunchFinished(ApplicationHandle &app) + void ApplicationManagerCommon::onLaunchFinished(ApplicationHandle &app) { // reset startupReason to default Launch app.startupReason = StartupReason::Launch; @@ -1082,7 +776,7 @@ namespace app::manager } } - auto ApplicationManager::handleCloseConfirmation(CloseConfirmation *msg) -> bool + auto ApplicationManagerCommon::handleCloseConfirmation(CloseConfirmation *msg) -> bool { auto senderApp = getApplication(msg->getSenderName()); if (senderApp == nullptr) { @@ -1093,7 +787,7 @@ namespace app::manager return onCloseConfirmed(*senderApp); } - auto ApplicationManager::onCloseConfirmed(ApplicationHandle &app) -> bool + auto ApplicationManagerCommon::onCloseConfirmed(ApplicationHandle &app) -> bool { if (isApplicationCloseable(&app)) { app.setState(ApplicationHandle::State::DEACTIVATED); @@ -1110,7 +804,7 @@ namespace app::manager return true; } - auto ApplicationManager::handleMessageAsAction(sys::Message *request) -> std::shared_ptr + auto ApplicationManagerCommon::handleMessageAsAction(sys::Message *request) -> std::shared_ptr { auto actionMsg = dynamic_cast(request); if (!actionMsg) { @@ -1122,73 +816,19 @@ namespace app::manager return std::make_shared(); } - void ApplicationManager::onPhoneLocked() - { - if (phoneLockHandler.isPhoneLocked()) { - autoLockTimer.stop(); - return; - } - if (auto focusedApp = getFocusedApplication(); focusedApp == nullptr || focusedApp->preventsAutoLocking()) { - autoLockTimer.start(); - return; - } - if (phoneModeObserver->isTetheringOn()) { - autoLockTimer.start(); - return; - } - if (event::service::api::isTorchOn()) { - autoLockTimer.start(); - return; - } - phoneLockHandler.handleLockRequest(); - } - - void ApplicationManager::displayLanguageChanged(std::string value) + void ApplicationManagerCommon::displayLanguageChanged(std::string value) { if (utils::setDisplayLanguage(value)) { rebuildActiveApplications(); } } - void ApplicationManager::lockTimeChanged(std::string value) - { - if (value.empty()) { - LOG_ERROR("No value for auto-locking time period, request ignored"); - return; - } - const auto interval = std::chrono::seconds{utils::getNumericValue(value)}; - if (interval.count() == 0) { - LOG_ERROR("Invalid auto-locking time period of 0s, request ignored"); - return; - } - autoLockTimer.restart(interval); - } - - auto ApplicationManager::handleAutoLockGetRequest([[maybe_unused]] GetAutoLockTimeoutRequest *request) - -> std::shared_ptr - { - auto intervalValue = - settings->getValue(settings::SystemProperties::autoLockTimeInSec, settings::SettingsScope::Global); - const auto interval = std::chrono::seconds{utils::getNumericValue(intervalValue)}; - return std::make_shared(interval); - } - auto ApplicationManager::handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request) - -> std::shared_ptr - { - auto interval = request->getValue(); - settings->setValue(settings::SystemProperties::autoLockTimeInSec, - utils::to_string(interval.count()), - settings::SettingsScope::Global); - autoLockTimer.restart(interval); - return std::make_shared(); - } - - void ApplicationManager::inputLanguageChanged(std::string value) + void ApplicationManagerCommon::inputLanguageChanged(std::string value) { utils::setInputLanguage(value); } - auto ApplicationManager::handleDOMRequest(sys::Message *request) -> std::shared_ptr + auto ApplicationManagerCommon::handleDOMRequest(sys::Message *request) -> std::shared_ptr { auto app = getFocusedApplication(); if (app != nullptr) { @@ -1200,33 +840,8 @@ namespace app::manager return std::make_shared(sys::ReturnCodes::Unresolved); } - auto ApplicationManager::handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer + auto ApplicationManagerCommon::handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer { - if (auto msg = dynamic_cast(request)) { - if (dynamic_cast(msg->event.get())) { - auto response = std::make_shared( - std::make_unique(phoneLockHandler.isPhoneLocked())); - bus.sendUnicast(std::move(response), service::name::service_desktop); - return sys::msgHandled(); - } - } return sys::msgNotHandled(); - } - - void ApplicationManager::processKeypadBacklightState(bsp::keypad_backlight::State keypadLightState) - { - auto action = bsp::keypad_backlight::Action::turnOff; - switch (keypadLightState) { - case bsp::keypad_backlight::State::on: - action = bsp::keypad_backlight::Action::turnOn; - break; - case bsp::keypad_backlight::State::activeMode: - action = bsp::keypad_backlight::Action::turnOnActiveMode; - break; - case bsp::keypad_backlight::State::off: - action = bsp::keypad_backlight::Action::turnOff; - break; - } - bus.sendUnicast(std::make_shared(action), service::name::evt_manager); - } + }; } // namespace app::manager diff --git a/module-services/service-cellular/CellularRequestHandler.cpp b/module-services/service-cellular/CellularRequestHandler.cpp index cab0fa43248d944d1d0e2785fb9a9227a23ec803..8207a947e30010d9244a630169dad5ce3bc811c1 100644 --- a/module-services/service-cellular/CellularRequestHandler.cpp +++ b/module-services/service-cellular/CellularRequestHandler.cpp @@ -22,7 +22,7 @@ #include "service-cellular/requests/CallWaitingRequest.hpp" #include "service-cellular/requests/RejectRequest.hpp" -#include +#include #include @@ -42,7 +42,7 @@ void CellularRequestHandler::handle(cellular::ImeiRequest &request, at::Result & } auto msg = std::make_shared(MMIResultParams::MMIResult::Success, response); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, service::name::appmgr); } void CellularRequestHandler::handle(cellular::UssdRequest &request, at::Result &result) @@ -77,11 +77,11 @@ void CellularRequestHandler::handle(cellular::RejectRequest &request, at::Result { if (request.getRejectReason() == cellular::RejectRequest::RejectReason::NoSim) { auto message = std::make_shared(request.getNumber()); - cellular.bus.sendUnicast(message, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(message, service::name::appmgr); } else if (request.getRejectReason() == cellular::RejectRequest::RejectReason::NotAnEmergencyNumber) { auto message = std::make_shared(request.getNumber()); - cellular.bus.sendUnicast(message, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(message, service::name::appmgr); } request.setHandled(true); } @@ -135,7 +135,7 @@ void CellularRequestHandler::handle(cellular::ClirRequest &request, at::Result & } } auto msg = std::make_shared(MMIResultParams::MMIResult::Success, response); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, ::service::name::appmgr); request.setHandled(requestHandled); } @@ -200,7 +200,7 @@ void CellularRequestHandler::handle(cellular::CallForwardingRequest &request, at response->addMessage(IMMICustomResultParams::MMIResultMessage::CommonFailure); } auto msg = std::make_shared(MMIResultParams::MMIResult::Success, response); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, ::service::name::appmgr); request.setHandled(requestHandled); } @@ -249,7 +249,7 @@ void CellularRequestHandler::handle(cellular::CallBarringRequest &request, at::R } auto msg = std::make_shared(MMIResultParams::MMIResult::Success, response); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, ::service::name::appmgr); request.setHandled(requestHandled); } @@ -287,7 +287,7 @@ void CellularRequestHandler::handle(cellular::ClipRequest &request, at::Result & } auto msg = std::make_shared(MMIResultParams::MMIResult::Success, response); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, ::service::name::appmgr); request.setHandled(requestHandled); } @@ -334,7 +334,7 @@ void CellularRequestHandler::handle(cellular::CallWaitingRequest &request, at::R response->addMessage(IMMICustomResultParams::MMIResultMessage::CommonFailure); } auto msg = std::make_shared(MMIResultParams::MMIResult::Success, response); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, ::service::name::appmgr); request.setHandled(requestHandled); } @@ -344,5 +344,5 @@ void CellularRequestHandler::sendMmiResult(bool result) auto msg = std::make_shared(result ? MMIResultParams::MMIResult::Success : MMIResultParams::MMIResult::Failed); - cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellular.bus.sendUnicast(msg, ::service::name::appmgr); } diff --git a/module-services/service-cellular/CellularUrcHandler.cpp b/module-services/service-cellular/CellularUrcHandler.cpp index f1f36d56d2cbe705b4368c45e5f01dc490861e6d..219787e4a9ea9dabd0916f6607f39902306b2872 100644 --- a/module-services/service-cellular/CellularUrcHandler.cpp +++ b/module-services/service-cellular/CellularUrcHandler.cpp @@ -9,6 +9,7 @@ #include #include +#include #include #include @@ -79,7 +80,7 @@ void CellularUrcHandler::Handle(Cusd &urc) cellularService.ussdState = ussd::State::pullResponseReceived; cellularService.setUSSDTimer(); auto msg = std::make_shared(*message); - cellularService.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellularService.bus.sendUnicast(msg, service::name::appmgr); } } else { @@ -87,7 +88,7 @@ void CellularUrcHandler::Handle(Cusd &urc) cellularService.ussdState = ussd::State::sesionAborted; cellularService.setUSSDTimer(); auto msg = std::make_shared(*message); - cellularService.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName); + cellularService.bus.sendUnicast(msg, service::name::appmgr); } urc.setHandled(true); diff --git a/module-services/service-cellular/ServiceCellular.cpp b/module-services/service-cellular/ServiceCellular.cpp index 17e5c762a1aa76c561575c05b8682c592b95deff..474e6e40971e6d1ca237b097f2033d18c690fbf1 100644 --- a/module-services/service-cellular/ServiceCellular.cpp +++ b/module-services/service-cellular/ServiceCellular.cpp @@ -63,6 +63,7 @@ #include #include #include +#include #include #include #include @@ -72,7 +73,6 @@ #include #include #include -#include #include #include #include @@ -426,7 +426,7 @@ void ServiceCellular::registerMessageHandlers() connect(typeid(CellularCallRequestMessage), [&](sys::Message *request) -> sys::MessagePointer { if (phoneModeObserver->isInMode(sys::phone_modes::PhoneMode::Offline)) { this->bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + ::service::name::appmgr); return std::make_shared(true); } diff --git a/module-services/service-cellular/src/ServiceCellularPriv.cpp b/module-services/service-cellular/src/ServiceCellularPriv.cpp index 0524c39116b63348f7b8634f9ab0dcf45eba053e..ba424e0cf5f44e7ed2480ddc83eb611d370e5f6e 100644 --- a/module-services/service-cellular/src/ServiceCellularPriv.cpp +++ b/module-services/service-cellular/src/ServiceCellularPriv.cpp @@ -15,7 +15,7 @@ #include #include -#include +#include #include "service-cellular/MessageConstants.hpp" #include "checkSmsCenter.hpp" @@ -136,7 +136,7 @@ namespace cellular::internal bool ret = false; if (owner->phoneModeObserver->isInMode(sys::phone_modes::PhoneMode::Offline)) { owner->bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + ::service::name::appmgr); ret = true; } return ret; diff --git a/module-services/service-desktop/ServiceDesktop.cpp b/module-services/service-desktop/ServiceDesktop.cpp index dd528762abc09fc3df7c5d1b330460675870688a..d739479e9b187ccaf911ec376ab274d0e2f9895a 100644 --- a/module-services/service-desktop/ServiceDesktop.cpp +++ b/module-services/service-desktop/ServiceDesktop.cpp @@ -23,7 +23,8 @@ #include #include -#include +#include +#include #include #include #include @@ -159,7 +160,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler() if (usbSecurityModel->isSecurityEnabled()) { LOG_INFO("Endpoint security enabled, requesting passcode"); - bus.sendUnicast(std::make_shared(), app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); } return sys::MessageNone{}; @@ -168,8 +169,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler() connect(sdesktop::usb::USBDisconnected(), [&](sys::Message *msg) { LOG_INFO("USB disconnected"); if (usbSecurityModel->isSecurityEnabled()) { - bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); } bus.sendUnicast(std::make_shared(sys::phone_modes::Tethering::Off), service::name::system_manager); diff --git a/module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp b/module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp index 06ffa3bf7630151b250aaa38b8975de43c99cde8..3229298b4f309bb3ed7bf973cf62bded0d4483a6 100644 --- a/module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp +++ b/module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp @@ -26,6 +26,7 @@ #include #include +#include namespace parserFSM { diff --git a/module-services/service-desktop/endpoints/developerMode/Mode/UI_Helper.cpp b/module-services/service-desktop/endpoints/developerMode/Mode/UI_Helper.cpp index 6d78e2c4450102e9d6036709163a481e68a4659a..b6ac28b7c072c5089441bdd0b8cd016d758cb484 100644 --- a/module-services/service-desktop/endpoints/developerMode/Mode/UI_Helper.cpp +++ b/module-services/service-desktop/endpoints/developerMode/Mode/UI_Helper.cpp @@ -6,7 +6,7 @@ #include "service-desktop/Constants.hpp" #include "service-desktop/DeveloperModeMessage.hpp" #include -#include +#include #include namespace parserFSM @@ -33,7 +33,7 @@ namespace parserFSM owner->bus.sendUnicast( std::make_shared(service::name::service_desktop, std::make_unique(std::move(event))), - app::manager::ApplicationManager::ServiceName); + service::name::appmgr); return {sent::delayed, std::nullopt}; } return {sent::no, std::nullopt}; diff --git a/module-services/service-desktop/endpoints/security/SecurityEndpointHelper.cpp b/module-services/service-desktop/endpoints/security/SecurityEndpointHelper.cpp index 3aec8f64ce23d0e78e1558e49fd9413fd7c93265..239cb3be9b2431349a433f36c30bfd34bb101e00 100644 --- a/module-services/service-desktop/endpoints/security/SecurityEndpointHelper.cpp +++ b/module-services/service-desktop/endpoints/security/SecurityEndpointHelper.cpp @@ -3,7 +3,7 @@ #include "SecurityEndpointHelper.hpp" #include -#include +#include #include #include #include @@ -73,9 +73,8 @@ auto SecurityEndpointHelper::processConfiguration(Context &context) -> http::Cod if (passCode.size() == PasscodeLength) { try { auto msg = std::make_shared(passCodeArrayToVecOfInts(passCode)); - status = owner->bus.sendUnicast(std::move(msg), app::manager::ApplicationManager::ServiceName) - ? http::Code::NoContent - : http::Code::InternalServerError; + status = owner->bus.sendUnicast(std::move(msg), service::name::appmgr) ? http::Code::NoContent + : http::Code::InternalServerError; } catch (const std::exception &e) { LOG_ERROR("Passcode decoding exception"); diff --git a/module-sys/SystemManager/SystemManager.cpp b/module-sys/SystemManager/SystemManager.cpp index 0198403fb2e45fb2ca80fc88c6e15794b6d448da..8a795272276b04ff1644d23a21a6f1cd17d76266 100644 --- a/module-sys/SystemManager/SystemManager.cpp +++ b/module-sys/SystemManager/SystemManager.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include "messages/CpuFrequencyMessage.hpp" #include "messages/DeviceRegistrationMessage.hpp" @@ -34,6 +34,10 @@ #include "Timers/TimerFactory.hpp" #include #include +#include +#include +#include +#include const inline size_t systemManagerStack = 4096 * 2; @@ -59,7 +63,7 @@ namespace sys service::name::gui, service::name::db, service::name::eink, - app::manager::ApplicationManager::ServiceName}; + service::name::appmgr}; } namespace restore @@ -68,7 +72,7 @@ namespace sys service::name::evt_manager, service::name::gui, service::name::eink, - app::manager::ApplicationManager::ServiceName}; + service::name::appmgr}; } namespace regularClose @@ -419,7 +423,7 @@ namespace sys LOG_INFO("Battery Critical Level reached!"); CellularServiceAPI::ChangeModulePowerState(this, cellular::service::State::PowerState::Off); auto msg = std::make_shared(true, charging); - bus.sendUnicast(std::move(msg), app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::move(msg), service::name::appmgr); } void SystemManager::batteryShutdownLevelAction() @@ -433,7 +437,7 @@ namespace sys LOG_INFO("Battery level normal."); CellularServiceAPI::ChangeModulePowerState(this, cellular::service::State::PowerState::On); auto battNormalMsg = std::make_shared(false); - bus.sendUnicast(std::move(battNormalMsg), app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::move(battNormalMsg), service::name::appmgr); } void SystemManager::readyToCloseHandler(Message *msg) @@ -599,7 +603,7 @@ namespace sys switch (Store::Battery::get().levelState) { case Store::Battery::LevelState::Normal: bus.sendUnicast(std::make_unique(app::manager::StartupType::Regular), - app::manager::ApplicationManager::ServiceName); + service::name::appmgr); break; case Store::Battery::LevelState::Shutdown: if (!lowBatteryShutdownDelay.isActive()) { @@ -609,12 +613,12 @@ namespace sys case Store::Battery::LevelState::CriticalNotCharging: bus.sendUnicast( std::make_unique(app::manager::StartupType::LowBattery), - app::manager::ApplicationManager::ServiceName); + service::name::appmgr); break; case Store::Battery::LevelState::CriticalCharging: bus.sendUnicast( std::make_unique(app::manager::StartupType::LowBatteryCharging), - app::manager::ApplicationManager::ServiceName); + service::name::appmgr); break; } return sys::MessageNone{}; @@ -731,8 +735,7 @@ namespace sys if (phoneModeSubject->isTetheringEnabled()) { LOG_WARN("Changing phone mode when tethering is enabled!"); // display popup - bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); return MessageNone{}; } phoneModeSubject->setPhoneMode(request->getPhoneMode()); @@ -749,14 +752,12 @@ namespace sys } if (const auto requestedState = request->getTetheringState(); requestedState == phone_modes::Tethering::On) { - bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); } else { if (const auto tetheringChanged = phoneModeSubject->setTetheringMode(phone_modes::Tethering::Off); !tetheringChanged) { - bus.sendUnicast(std::make_shared(), - app::manager::ApplicationManager::ServiceName); + bus.sendUnicast(std::make_shared(), service::name::appmgr); } else { // Turned on, disabling... diff --git a/products/BellHybrid/BellHybridMain.cpp b/products/BellHybrid/BellHybridMain.cpp index 87eb40d56e7e54d397045159eb5af25e65535dd4..4b7f3220a62422b1197a78ce3f00f980f0e1a3a0 100644 --- a/products/BellHybrid/BellHybridMain.cpp +++ b/products/BellHybrid/BellHybridMain.cpp @@ -9,10 +9,11 @@ #include // services +#include #include #include #include -#include +#include #include #include #include @@ -98,7 +99,7 @@ int main() // start application manager return sysmgr->RunSystemService( std::make_shared( - app::manager::ApplicationManager::ServiceName, std::move(applications), app::applicationBellName), + service::name::appmgr, std::move(applications), app::applicationBellName), sysmgr.get()); }); diff --git a/products/BellHybrid/CMakeLists.txt b/products/BellHybrid/CMakeLists.txt index 99ab128da89552ee897ad7ab68f5a5f8710b170b..94799f6e2c658d5fefe84485368f07a0762c02db 100644 --- a/products/BellHybrid/CMakeLists.txt +++ b/products/BellHybrid/CMakeLists.txt @@ -40,6 +40,7 @@ target_link_libraries(BellHybrid application-bell-main application-bell-settings application-music-player + appmgr evtmgr messagetype module-apps diff --git a/products/BellHybrid/services/CMakeLists.txt b/products/BellHybrid/services/CMakeLists.txt index 730345a5fa91f22c7a52894339b4e5b5664218a0..b883aaf9580acbff6e62f39d3da2ce316c25aa98 100644 --- a/products/BellHybrid/services/CMakeLists.txt +++ b/products/BellHybrid/services/CMakeLists.txt @@ -1 +1,2 @@ add_subdirectory(evtmgr) +add_subdirectory(appmgr) diff --git a/products/BellHybrid/services/appmgr/ApplicationManager.cpp b/products/BellHybrid/services/appmgr/ApplicationManager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f218261d873c32a604c7f1555c9ff08304bc2efb --- /dev/null +++ b/products/BellHybrid/services/appmgr/ApplicationManager.cpp @@ -0,0 +1,26 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include + +#include + +namespace app::manager +{ + auto ApplicationManager::startApplication(ApplicationHandle &app) -> bool + { + if (not ApplicationManagerCommon::startApplication(app)) { + LOG_INFO("Starting application %s", app.name().c_str()); + app.run(sys::phone_modes::PhoneMode::Offline, this); + } + return true; + } + + auto ApplicationManager::resolveHomeApplication() -> std::string + { + if (checkOnBoarding()) { + return app::name_onboarding; + } + return rootApplicationName; + } +} // namespace app::manager diff --git a/products/BellHybrid/services/appmgr/CMakeLists.txt b/products/BellHybrid/services/appmgr/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..8ed5c1ddc2d0aef97ed58cabd32f9da045ba75ba --- /dev/null +++ b/products/BellHybrid/services/appmgr/CMakeLists.txt @@ -0,0 +1,19 @@ +add_library(appmgr STATIC) + +target_sources(appmgr + PRIVATE + ApplicationManager.cpp + PUBLIC + include/appmgr/ApplicationManager.hpp +) + +target_include_directories(appmgr + PUBLIC + $ +) + +target_link_libraries(appmgr + PRIVATE + module-apps + service-appmgr +) diff --git a/products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp b/products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp new file mode 100644 index 0000000000000000000000000000000000000000..f87587fece8a2e28ef6ad006c8889186df765095 --- /dev/null +++ b/products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp @@ -0,0 +1,25 @@ +// 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 + +namespace app::manager +{ + class ApplicationManager : public ApplicationManagerCommon + { + public: + ApplicationManager(const ApplicationName &serviceName, + std::vector> &&launchers, + const ApplicationName &_rootApplicationName) + : ApplicationManagerCommon(serviceName, std::move(launchers), _rootApplicationName) + { + registerMessageHandlers(); + } + + private: + auto startApplication(ApplicationHandle &app) -> bool override; + auto resolveHomeApplication() -> std::string override; + }; +} // namespace app::manager diff --git a/products/PurePhone/CMakeLists.txt b/products/PurePhone/CMakeLists.txt index 7107d0875adb686b4a6d54d6c62e4b2bda31e1d4..a0158cc1e7bda4e91acb3c15b76b13d6fab72a8e 100644 --- a/products/PurePhone/CMakeLists.txt +++ b/products/PurePhone/CMakeLists.txt @@ -55,6 +55,7 @@ target_link_libraries(PurePhone application-phonebook application-settings application-special-input + appmgr evtmgr messagetype module-apps diff --git a/products/PurePhone/PurePhoneMain.cpp b/products/PurePhone/PurePhoneMain.cpp index 1e22278a2c893f5aceb076c973e61c4dfdc9939b..87b582556e3e28569edd59d80dac8f68c155ec29 100644 --- a/products/PurePhone/PurePhoneMain.cpp +++ b/products/PurePhone/PurePhoneMain.cpp @@ -22,8 +22,9 @@ #include // services +#include #include -#include +#include #include #include #include @@ -169,10 +170,9 @@ int main() applications.push_back(app::CreateLauncher(app::name_onboarding)); #endif // start application manager - return sysmgr->RunSystemService( - std::make_shared( - app::manager::ApplicationManager::ServiceName, std::move(applications), app::name_desktop), - sysmgr.get()); + return sysmgr->RunSystemService(std::make_shared( + service::name::appmgr, std::move(applications), app::name_desktop), + sysmgr.get()); }); LOG_PRINTF("Launching PurePhone \n"); diff --git a/products/PurePhone/services/CMakeLists.txt b/products/PurePhone/services/CMakeLists.txt index 730345a5fa91f22c7a52894339b4e5b5664218a0..b883aaf9580acbff6e62f39d3da2ce316c25aa98 100644 --- a/products/PurePhone/services/CMakeLists.txt +++ b/products/PurePhone/services/CMakeLists.txt @@ -1 +1,2 @@ add_subdirectory(evtmgr) +add_subdirectory(appmgr) diff --git a/products/PurePhone/services/appmgr/ApplicationManager.cpp b/products/PurePhone/services/appmgr/ApplicationManager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a8340007e763e0c323e6219c923b123cd3fdfeb8 --- /dev/null +++ b/products/PurePhone/services/appmgr/ApplicationManager.cpp @@ -0,0 +1,478 @@ +// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved. +// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace app::manager +{ + namespace + { + constexpr auto autoLockTimerName = "AutoLockTimer"; + } // namespace + + ApplicationManager::ApplicationManager(const ApplicationName &serviceName, + std::vector> &&launchers, + const ApplicationName &_rootApplicationName) + : ApplicationManagerCommon(serviceName, std::move(launchers), _rootApplicationName), + phoneModeObserver(std::make_shared()), + phoneLockHandler(locks::PhoneLockHandler(this, settings)), + simLockHandler(this), notificationsConfig{phoneModeObserver, settings, phoneLockHandler}, + notificationsHandler{this, notificationsConfig}, notificationProvider{this, notificationsConfig} + { + autoLockTimer = sys::TimerFactory::createSingleShotTimer( + this, autoLockTimerName, sys::timer::InfiniteTimeout, [this](sys::Timer &) { onPhoneLocked(); }); + + bus.channels.push_back(sys::BusChannel::PhoneModeChanges); + bus.channels.push_back(sys::BusChannel::PhoneLockChanges); + bus.channels.push_back(sys::BusChannel::ServiceCellularNotifications); + registerMessageHandlers(); + } + + sys::ReturnCodes ApplicationManager::InitHandler() + { + ApplicationManagerCommon::InitHandler(); + + startBackgroundApplications(); + + phoneLockHandler.enablePhoneLock((utils::getNumericValue( + settings->getValue(settings::SystemProperties::lockScreenPasscodeIsOn, settings::SettingsScope::Global)))); + + phoneLockHandler.setPhoneLockHash( + settings->getValue(settings::SystemProperties::lockPassHash, settings::SettingsScope::Global)); + + settings->registerValueChange( + settings::SystemProperties::lockScreenPasscodeIsOn, + [this](const std::string &value) { phoneLockHandler.enablePhoneLock(utils::getNumericValue(value)); }, + settings::SettingsScope::Global); + + settings->registerValueChange( + settings::SystemProperties::lockPassHash, + [this](const std::string &value) { phoneLockHandler.setPhoneLockHash(value); }, + settings::SettingsScope::Global); + + settings->registerValueChange( + ::settings::KeypadLight::state, + [this](const std::string &value) { + const auto keypadLightState = + static_cast(utils::getNumericValue(value)); + processKeypadBacklightState(keypadLightState); + }, + ::settings::SettingsScope::Global); + + settings->registerValueChange( + settings::SystemProperties::autoLockTimeInSec, + [this](std::string value) { lockTimeChanged(std::move(value)); }, + settings::SettingsScope::Global); + + return sys::ReturnCodes::Success; + } + + void ApplicationManager::processKeypadBacklightState(bsp::keypad_backlight::State keypadLightState) + { + auto action = bsp::keypad_backlight::Action::turnOff; + switch (keypadLightState) { + case bsp::keypad_backlight::State::on: + action = bsp::keypad_backlight::Action::turnOn; + break; + case bsp::keypad_backlight::State::activeMode: + action = bsp::keypad_backlight::Action::turnOnActiveMode; + break; + case bsp::keypad_backlight::State::off: + action = bsp::keypad_backlight::Action::turnOff; + break; + } + bus.sendUnicast(std::make_shared(action), service::name::evt_manager); + } + + void ApplicationManager::startBackgroundApplications() + { + for (const auto &name : std::vector{app::special_input}) { + if (auto app = getApplication(name); app != nullptr) { + app->runInBackground(phoneModeObserver->getCurrentPhoneMode(), this); + } + } + } + + void ApplicationManager::registerMessageHandlers() + { + ApplicationManagerCommon::registerMessageHandlers(); + + phoneModeObserver->connect(this); + phoneModeObserver->subscribe([this](sys::phone_modes::PhoneMode phoneMode) { + handlePhoneModeChanged(phoneMode); + actionsRegistry.enqueue( + ActionEntry{actions::ShowPopup, std::make_unique(phoneMode)}); + }); + + phoneModeObserver->subscribe( + [this](sys::phone_modes::Tethering tethering) { handleTetheringChanged(tethering); }); + + notificationsHandler.registerMessageHandlers(); + + connect(typeid(PreventBlockingRequest), [this]([[maybe_unused]] sys::Message *msg) { + if (!phoneLockHandler.isPhoneLocked()) { + autoLockTimer.start(); + } + return std::make_shared(); + }); + connect(typeid(GetAllNotificationsRequest), [&](sys::Message *request) { + notificationProvider.requestNotSeenNotifications(); + notificationProvider.send(); + return sys::msgHandled(); + }); + connect(typeid(db::NotificationMessage), [&](sys::Message *msg) { + auto msgl = static_cast(msg); + notificationProvider.handle(msgl); + return sys::msgHandled(); + }); + + // PhoneLock connects + connect(typeid(locks::LockPhone), + [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleLockRequest(); }); + connect(typeid(locks::UnlockPhone), + [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleUnlockRequest(); }); + connect(typeid(locks::CancelUnlockPhone), [&](sys::Message *request) -> sys::MessagePointer { + return phoneLockHandler.handleUnlockCancelRequest(); + }); + connect(typeid(locks::UnLockPhoneInput), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + return phoneLockHandler.handlePhoneLockInput(data->getInputData()); + }); + connect(typeid(locks::EnablePhoneLock), + [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleEnablePhoneLock(); }); + connect(typeid(locks::DisablePhoneLock), [&](sys::Message *request) -> sys::MessagePointer { + return phoneLockHandler.handleDisablePhoneLock(); + }); + connect(typeid(locks::UnlockedPhone), [&](sys::Message *request) -> sys::MessagePointer { + autoLockTimer.start(); + return simLockHandler.releaseSimUnlockBlockOnLockedPhone(); + }); + connect(typeid(locks::ChangePhoneLock), + [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleChangePhoneLock(); }); + connect(typeid(locks::SetPhoneLock), + [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleSetPhoneLock(); }); + connect(typeid(locks::SkipSetPhoneLock), [&](sys::Message *request) -> sys::MessagePointer { + return phoneLockHandler.handleSkipSetPhoneLock(); + }); + connect(typeid(GetAutoLockTimeoutRequest), [&](sys::Message *request) -> sys::MessagePointer { + auto req = static_cast(request); + return handleAutoLockGetRequest(req); + }); + connect(typeid(SetAutoLockTimeoutRequest), [&](sys::Message *request) -> sys::MessagePointer { + auto req = static_cast(request); + return handleAutoLockSetRequest(req); + }); + connect(typeid(locks::ExternalUnLockPhone), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + return phoneLockHandler.handleExternalUnlockRequest(data->getInputData()); + }); + connect(typeid(locks::ExternalPhoneLockAvailabilityChange), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + return phoneLockHandler.handleExternalAvailabilityChange(data->getAvailability()); + }); + + // SimLock connects + connect(typeid(cellular::msg::notification::SimNeedPin), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (phoneLockHandler.isPhoneLocked()) { + simLockHandler.setSimUnlockBlockOnLockedPhone(); + } + return simLockHandler.handleSimPinRequest(data->attempts); + }); + connect(typeid(cellular::msg::request::sim::PinUnlock::Response), + [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (data->retCode) { + return simLockHandler.handleSimUnlockedMessage(); + } + return sys::msgNotHandled(); + }); + connect(typeid(locks::UnLockSimInput), [&](sys::Message *request) -> sys::MessagePointer { + auto msg = static_cast(request); + return simLockHandler.verifySimLockInput(msg->getInputData()); + }); + connect(typeid(cellular::msg::notification::SimNeedPuk), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (phoneLockHandler.isPhoneLocked()) { + simLockHandler.setSimUnlockBlockOnLockedPhone(); + } + return simLockHandler.handleSimPukRequest(data->attempts); + }); + connect(typeid(cellular::msg::request::sim::UnblockWithPuk::Response), + [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (data->retCode) { + return simLockHandler.handleSimUnlockedMessage(); + } + return sys::msgNotHandled(); + }); + connect(typeid(locks::ChangeSimPin), [&](sys::Message *request) -> sys::MessagePointer { + return simLockHandler.handleSimPinChangeRequest(); + }); + connect(typeid(cellular::msg::request::sim::ChangePin::Response), + [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (data->retCode) { + return simLockHandler.handleSimPinChangedMessage(); + } + else { + return simLockHandler.handleSimPinChangeFailedRequest(); + } + }); + connect(typeid(locks::EnableSimPin), + [&](sys::Message *request) -> sys::MessagePointer { return simLockHandler.handleSimEnableRequest(); }); + connect(typeid(locks::DisableSimPin), + [&](sys::Message *request) -> sys::MessagePointer { return simLockHandler.handleSimDisableRequest(); }); + connect(typeid(cellular::msg::request::sim::SetPinLock::Response), + [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (data->retCode) { + return simLockHandler.handleSimAvailabilityMessage(); + } + else { + if (data->lock == cellular::api::SimLockState::Enabled) { + return simLockHandler.handleSimEnableRequest(); + } + else { + return simLockHandler.handleSimDisableRequest(); + } + } + }); + connect(typeid(cellular::msg::notification::SimBlocked), [&](sys::Message *request) -> sys::MessagePointer { + if (phoneLockHandler.isPhoneLocked()) { + simLockHandler.setSimUnlockBlockOnLockedPhone(); + } + return simLockHandler.handleSimBlockedRequest(); + }); + connect(typeid(cellular::msg::notification::UnhandledCME), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (phoneLockHandler.isPhoneLocked()) { + simLockHandler.setSimUnlockBlockOnLockedPhone(); + } + return simLockHandler.handleCMEErrorRequest(data->code); + }); + connect(typeid(locks::SetSim), [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + simLockHandler.setSim(data->getSimSlot()); + return sys::msgHandled(); + }); + connect(typeid(cellular::msg::request::sim::SetActiveSim::Response), + [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (data->retCode) { + settings->setValue(::settings::SystemProperties::activeSim, + utils::enumToString(Store::GSM::get()->selected), + ::settings::SettingsScope::Global); + return sys::msgHandled(); + } + return sys::msgNotHandled(); + }); + connect(typeid(cellular::msg::notification::SimReady), + [&](sys::Message *request) -> sys::MessagePointer { return simLockHandler.handleSimReadyMessage(); }); + connect(typeid(cellular::msg::notification::ModemStateChanged), + [&](sys::Message *request) -> sys::MessagePointer { + auto data = static_cast(request); + if (data->state == cellular::api::ModemState::Ready) { + simLockHandler.setSimReady(); + simLockHandler.getSettingsSimSelect( + settings->getValue(settings::SystemProperties::activeSim, settings::SettingsScope::Global)); + return sys::msgHandled(); + } + return sys::msgNotHandled(); + }); + connect(typeid(db::QueryResponse), [&](sys::Message *msg) { + auto response = static_cast(msg); + handleDBResponse(response); + return sys::msgHandled(); + }); + + auto convertibleToActionHandler = [this](sys::Message *request) { return handleMessageAsAction(request); }; + connect(typeid(CellularMMIResultMessage), convertibleToActionHandler); + connect(typeid(CellularMMIResponseMessage), convertibleToActionHandler); + connect(typeid(CellularMMIPushMessage), convertibleToActionHandler); + connect(typeid(CellularNoSimNotification), convertibleToActionHandler); + connect(typeid(CellularNotAnEmergencyNotification), convertibleToActionHandler); + connect(typeid(CellularSmsNoSimRequestMessage), convertibleToActionHandler); + connect(typeid(CellularSMSRejectedByOfflineNotification), convertibleToActionHandler); + connect(typeid(CellularCallRejectedByOfflineNotification), convertibleToActionHandler); + connect(typeid(sys::TetheringQuestionRequest), convertibleToActionHandler); + connect(typeid(sys::TetheringQuestionAbort), convertibleToActionHandler); + connect(typeid(sys::TetheringPhoneModeChangeProhibitedMessage), convertibleToActionHandler); + connect(typeid(CellularCallAbortedNotification), convertibleToActionHandler); + connect(typeid(CellularRingingMessage), convertibleToActionHandler); + connect(typeid(CellularCallActiveNotification), convertibleToActionHandler); + connect(typeid(CellularHangupCallMessage), convertibleToActionHandler); + } + + void ApplicationManager::handlePhoneModeChanged(sys::phone_modes::PhoneMode phoneMode) + { + for (const auto app : getStackedApplications()) { + changePhoneMode(phoneMode, app); + } + } + + void ApplicationManager::changePhoneMode(sys::phone_modes::PhoneMode phoneMode, const ApplicationHandle *app) + { + ActionEntry action{actions::PhoneModeChanged, std::make_unique(phoneMode)}; + action.setTargetApplication(app->name()); + actionsRegistry.enqueue(std::move(action)); + } + + void ApplicationManager::handleTetheringChanged(sys::phone_modes::Tethering tethering) + { + notificationProvider.handle(tethering); + } + + auto ApplicationManager::handleAutoLockGetRequest([[maybe_unused]] GetAutoLockTimeoutRequest *request) + -> std::shared_ptr + { + auto intervalValue = + settings->getValue(settings::SystemProperties::autoLockTimeInSec, settings::SettingsScope::Global); + const auto interval = std::chrono::seconds{utils::getNumericValue(intervalValue)}; + return std::make_shared(interval); + } + + auto ApplicationManager::handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request) + -> std::shared_ptr + { + auto interval = request->getValue(); + settings->setValue(settings::SystemProperties::autoLockTimeInSec, + utils::to_string(interval.count()), + settings::SettingsScope::Global); + autoLockTimer.restart(interval); + return std::make_shared(); + } + + auto ApplicationManager::handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer + { + if (auto msg = dynamic_cast(request)) { + if (dynamic_cast(msg->event.get())) { + auto response = std::make_shared( + std::make_unique(phoneLockHandler.isPhoneLocked())); + bus.sendUnicast(std::move(response), service::name::service_desktop); + return sys::msgHandled(); + } + } + return sys::msgNotHandled(); + } + + void ApplicationManager::lockTimeChanged(std::string value) + { + if (value.empty()) { + LOG_ERROR("No value for auto-locking time period, request ignored"); + return; + } + const auto interval = std::chrono::seconds{utils::getNumericValue(value)}; + if (interval.count() == 0) { + LOG_ERROR("Invalid auto-locking time period of 0s, request ignored"); + return; + } + autoLockTimer.restart(interval); + } + + void ApplicationManager::onPhoneLocked() + { + if (phoneLockHandler.isPhoneLocked()) { + autoLockTimer.stop(); + return; + } + if (auto focusedApp = getFocusedApplication(); focusedApp == nullptr || focusedApp->preventsAutoLocking()) { + autoLockTimer.start(); + return; + } + if (phoneModeObserver->isTetheringOn()) { + autoLockTimer.start(); + return; + } + if (event::service::api::isTorchOn()) { + autoLockTimer.start(); + return; + } + phoneLockHandler.handleLockRequest(); + } + + auto ApplicationManager::startApplication(ApplicationHandle &app) -> bool + { + if (not ApplicationManagerCommon::startApplication(app)) { + LOG_INFO("Starting application %s", app.name().c_str()); + app.run(phoneModeObserver->getCurrentPhoneMode(), this); + } + return true; + } + + auto ApplicationManager::resolveHomeWindow() -> std::string + { + return phoneLockHandler.isPhoneLocked() ? gui::popup::window::phone_lock_window + : gui::name::window::main_window; + } + + auto ApplicationManager::resolveHomeApplication() -> std::string + { + if (checkOnBoarding()) { + phoneLockHandler.handleUnlockRequest(); + return app::name_onboarding; + } + return rootApplicationName; + } + + auto ApplicationManager::handleDBResponse(db::QueryResponse *msg) -> bool + { + auto result = msg->getResult(); + if (auto response = dynamic_cast(result.get())) { + notificationProvider.handle(response); + return true; + } + return false; + } + + auto ApplicationManager::handlePhoneModeChangedAction(ActionEntry &action) -> ActionProcessStatus + { + const auto &targetName = action.target; + auto targetApp = getApplication(targetName); + if (targetApp == nullptr || !targetApp->handles(action.actionId)) { + return ActionProcessStatus::Dropped; + } + + if (targetApp->state() == ApplicationHandle::State::ACTIVE_FORGROUND || + targetApp->state() == ApplicationHandle::State::ACTIVE_BACKGROUND) { + app::Application::requestAction(this, targetName, action.actionId, std::move(action.params)); + return ActionProcessStatus::Accepted; + } + return ActionProcessStatus::Skipped; + } + + auto ApplicationManager::handleAction(ActionEntry &action) -> ActionProcessStatus + { + const auto status = ApplicationManagerCommon::handleAction(action); + if (status != ActionProcessStatus::NotHandled) { + return status; + } + switch (action.actionId) { + case actions::PhoneModeChanged: + return handlePhoneModeChangedAction(action); + default: + return ActionProcessStatus::NotHandled; + } + } +} // namespace app::manager diff --git a/products/PurePhone/services/appmgr/CMakeLists.txt b/products/PurePhone/services/appmgr/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..4228d662dde8d2466e2b60691b90058a5c3a897f --- /dev/null +++ b/products/PurePhone/services/appmgr/CMakeLists.txt @@ -0,0 +1,27 @@ +add_library(appmgr STATIC) + +target_sources(appmgr + PRIVATE + ApplicationManager.cpp + PUBLIC + include/appmgr/ApplicationManager.hpp +) + +target_include_directories(appmgr + PUBLIC + $ +) + +target_link_libraries(appmgr + PRIVATE + application-special-input + apps-common + module-apps + module-db + module-sys + service-appmgr + service-cellular + service-db + service-desktop + service-evtmgr +) diff --git a/products/PurePhone/services/appmgr/include/appmgr/ApplicationManager.hpp b/products/PurePhone/services/appmgr/include/appmgr/ApplicationManager.hpp new file mode 100644 index 0000000000000000000000000000000000000000..77f6f67e27e0dc3c01236633b0cbcca6e81df497 --- /dev/null +++ b/products/PurePhone/services/appmgr/include/appmgr/ApplicationManager.hpp @@ -0,0 +1,56 @@ +// 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 + +namespace app::manager +{ + class ApplicationManager : public ApplicationManagerCommon + { + public: + ApplicationManager(const ApplicationName &serviceName, + std::vector> &&launchers, + const ApplicationName &_rootApplicationName); + + private: + auto InitHandler() -> sys::ReturnCodes override; + void changePhoneMode(sys::phone_modes::PhoneMode phoneMode, const ApplicationHandle *app); + void handlePhoneModeChanged(sys::phone_modes::PhoneMode phoneMode); + void handleTetheringChanged(sys::phone_modes::Tethering tethering); + void processKeypadBacklightState(bsp::keypad_backlight::State keypadLightState); + void registerMessageHandlers() override; + void startBackgroundApplications(); + auto handleAutoLockGetRequest(GetAutoLockTimeoutRequest *request) -> std::shared_ptr; + auto handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request) -> std::shared_ptr; + auto handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer override; + void lockTimeChanged(std::string value); + /// @brief method is called on auto-locking timer tick event (blockTimer) + /// @detailed It sends AutoLock action to ApplicationDesktop to lock the screen. + /// @note AutoLock action is sent only if following conditions are met: + /// - tethering is off + /// - focused application is not preventing AutoLock + void onPhoneLocked(); + auto startApplication(ApplicationHandle &app) -> bool override; + auto resolveHomeWindow() -> std::string override; + auto resolveHomeApplication() -> std::string override; + auto handleDBResponse(db::QueryResponse *msg) -> bool; + auto handlePhoneModeChangedAction(ActionEntry &action) -> ActionProcessStatus; + auto handleAction(ActionEntry &action) -> ActionProcessStatus override; + + std::shared_ptr phoneModeObserver; + locks::PhoneLockHandler phoneLockHandler; + locks::SimLockHandler simLockHandler; + + notifications::NotificationsConfiguration notificationsConfig; + notifications::NotificationsHandler notificationsHandler; + notifications::NotificationProvider notificationProvider; + + //< auto-lock timer to count time from last user's activity. + // If it reaches time defined in settings database application + // manager is sending signal to Application Desktop in order to + // lock screen. + sys::TimerHandle autoLockTimer; + }; +} // namespace app::manager