M module-apps/application-calllog/windows/CallLogDetailsWindow.cpp => module-apps/application-calllog/windows/CallLogDetailsWindow.cpp +0 -1
@@ 6,7 6,6 @@
#include <functional>
#include <OptionsWindow.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include "ApplicationCallLog.hpp"
#include "data/CallLogInternals.hpp"
#include "data/CallLogSwitchData.hpp"
M module-apps/application-calllog/windows/CallLogMainWindow.cpp => module-apps/application-calllog/windows/CallLogMainWindow.cpp +0 -1
@@ 6,7 6,6 @@
#include "ApplicationCallLog.hpp"
#include "widgets/CalllogItem.hpp"
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <service-db/DBCalllogMessage.hpp>
#include <i18n/i18n.hpp>
#include <Label.hpp>
M module-apps/application-clock/ApplicationClock.cpp => module-apps/application-clock/ApplicationClock.cpp +0 -1
@@ 9,7 9,6 @@
#include <log.hpp>
#include <service-evtmgr/EVMessages.hpp>
#include <service-evtmgr/EventManagerCommon.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <module-sys/Timers/TimerFactory.hpp>
// MessageType
#include "MessageType.hpp"
M module-apps/application-desktop/models/ActiveNotificationsModel.cpp => module-apps/application-desktop/models/ActiveNotificationsModel.cpp +2 -1
@@ 10,6 10,7 @@
#include <gsl/assert>
#include <module-db/queries/notifications/QueryNotificationsClear.hpp>
#include <queries/messages/threads/QueryThreadGetByNumber.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/Controller.hpp>
#include <service-appmgr/messages/SwitchRequest.hpp>
@@ 51,7 52,7 @@ namespace
auto data = std::make_unique<SMSThreadData>(std::make_shared<ThreadRecord>(result->getThread()));
auto request = std::make_shared<app::manager::SwitchRequest>(
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::ApplicationDesktop *>(app));
M module-apps/application-desktop/windows/ChargingBatteryWindow.cpp => module-apps/application-desktop/windows/ChargingBatteryWindow.cpp +0 -1
@@ 8,7 8,6 @@
#include <gui/widgets/Image.hpp>
#include <log.hpp>
#include <service-appmgr/Controller.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
namespace gui
{
M module-apps/application-desktop/windows/DeadBatteryWindow.cpp => module-apps/application-desktop/windows/DeadBatteryWindow.cpp +0 -1
@@ 9,7 9,6 @@
#include <InputEvent.hpp>
#include <log.hpp>
#include <service-appmgr/Controller.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
namespace gui
{
M module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp => module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp +0 -1
@@ 7,7 7,6 @@
#include <i18n/i18n.hpp>
#include <service-appmgr/data/MmiActionsParams.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
using namespace gui;
M module-apps/application-desktop/windows/MmiPullWindow.cpp => module-apps/application-desktop/windows/MmiPullWindow.cpp +0 -1
@@ 7,7 7,6 @@
#include <i18n/i18n.hpp>
#include <service-appmgr/data/MmiActionsParams.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <string>
M module-apps/application-desktop/windows/MmiPushWindow.cpp => module-apps/application-desktop/windows/MmiPushWindow.cpp +1 -1
@@ 6,8 6,8 @@
#include <i18n/i18n.hpp>
#include <Image.hpp>
+#include <apps-common/Application.hpp>
#include <service-appmgr/data/MmiActionsParams.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
using namespace gui;
M module-apps/application-messages/windows/MessagesMainWindow.cpp => module-apps/application-messages/windows/MessagesMainWindow.cpp +0 -1
@@ 15,7 15,6 @@
#include <log.hpp>
#include <module-db/queries/messages/threads/QueryThreadGetByContactID.hpp>
#include <module-db/queries/notifications/QueryNotificationsClear.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <service-db/DBNotificationMessage.hpp>
#include <service-db/DBServiceAPI.hpp>
#include <Style.hpp>
M module-apps/application-onboarding/ApplicationOnBoarding.cpp => module-apps/application-onboarding/ApplicationOnBoarding.cpp +4 -3
@@ 17,8 17,10 @@
#include "windows/OnBoardingChangeDateAndTimeWindow.hpp"
#include <application-settings/windows/system/ChangeTimeZone.hpp>
+#include <apps-common/locks/data/PhoneLockMessages.hpp>
#include <module-services/service-db/agents/settings/SystemSettings.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
+#include <service-appmgr/messages/GetCurrentDisplayLanguageResponse.hpp>
namespace app
{
@@ 102,8 104,7 @@ namespace app
void ApplicationOnBoarding::finalizeOnBoarding()
{
- bus.sendUnicast(std::make_shared<onBoarding::FinalizeOnBoarding>(),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<onBoarding::FinalizeOnBoarding>(), service::name::appmgr);
}
sys::ReturnCodes ApplicationOnBoarding::DeinitHandler()
M module-apps/application-settings/ApplicationSettings.cpp => module-apps/application-settings/ApplicationSettings.cpp +3 -5
@@ 63,8 63,8 @@
#include <Dialog.hpp>
#include <messages/DialogMetadataMessage.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/messages/GetCurrentDisplayLanguageResponse.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <service-bluetooth/BluetoothMessage.hpp>
#include <service-bluetooth/Constants.hpp>
#include <service-bluetooth/messages/BondedDevices.hpp>
@@ 703,8 703,7 @@ namespace app
void ApplicationSettings::getAutoLockTime()
{
- bus.sendUnicast(std::make_shared<app::manager::GetAutoLockTimeoutRequest>(),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<app::manager::GetAutoLockTimeoutRequest>(), 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<app::manager::SetAutoLockTimeoutRequest>(lockTime),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<app::manager::SetAutoLockTimeoutRequest>(lockTime), service::name::appmgr);
}
void ApplicationSettings::switchToAllDevicesViaBtErrorPrompt(std::shared_ptr<sys::DataMessage> msg,
M module-apps/apps-common/Application.cpp => module-apps/apps-common/Application.cpp +1 -0
@@ 36,6 36,7 @@
#include <WindowsFactory.hpp>
#include <service-gui/Common.hpp>
#include <module-utils/Utils.hpp>
+#include <service-db/service-db/Settings.hpp>
#include <service-db/agents/settings/SystemSettings.hpp>
#include <service-audio/AudioServiceAPI.hpp> // for GetOutputVolume
M module-apps/apps-common/locks/handlers/PhoneLockSubject.cpp => module-apps/apps-common/locks/handlers/PhoneLockSubject.cpp +9 -10
@@ 3,7 3,7 @@
#include "PhoneLockSubject.hpp"
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <locks/data/PhoneLockMessages.hpp>
namespace locks
@@ 17,42 17,41 @@ namespace locks
void PhoneLockSubject::unlock()
{
- owner->bus.sendUnicast(std::make_shared<UnlockPhone>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<UnlockPhone>(), service::name::appmgr);
}
void PhoneLockSubject::lock()
{
- owner->bus.sendUnicast(std::make_shared<LockPhone>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<LockPhone>(), service::name::appmgr);
}
void PhoneLockSubject::enablePhoneLock()
{
- owner->bus.sendUnicast(std::make_shared<EnablePhoneLock>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<EnablePhoneLock>(), service::name::appmgr);
}
void PhoneLockSubject::disablePhoneLock()
{
- owner->bus.sendUnicast(std::make_shared<DisablePhoneLock>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<DisablePhoneLock>(), service::name::appmgr);
}
void PhoneLockSubject::changePhoneLock()
{
- owner->bus.sendUnicast(std::make_shared<ChangePhoneLock>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<ChangePhoneLock>(), service::name::appmgr);
}
void PhoneLockSubject::setPhoneLock()
{
- owner->bus.sendUnicast(std::make_shared<SetPhoneLock>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<SetPhoneLock>(), service::name::appmgr);
}
void PhoneLockSubject::skipSetPhoneLock()
{
- owner->bus.sendUnicast(std::make_shared<SkipSetPhoneLock>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<SkipSetPhoneLock>(), service::name::appmgr);
}
void PhoneLockSubject::verifyInput(LockInput inputData)
{
- owner->bus.sendUnicast(std::make_shared<UnLockPhoneInput>(inputData),
- app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<UnLockPhoneInput>(inputData), service::name::appmgr);
}
} // namespace locks
M module-apps/apps-common/locks/handlers/SimLockSubject.cpp => module-apps/apps-common/locks/handlers/SimLockSubject.cpp +8 -8
@@ 3,8 3,9 @@
#include "SimLockSubject.hpp"
-#include <locks/data/PhoneLockMessages.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <apps-common/locks/data/PhoneLockMessages.hpp>
+#include <apps-common/locks/data/SimLockMessages.hpp>
+#include <service-appmgr/Constants.hpp>
namespace locks
{
@@ 17,27 18,26 @@ namespace locks
void SimLockSubject::setSim(cellular::api::SimSlot simSlot)
{
- owner->bus.sendUnicast(std::make_shared<locks::SetSim>(simSlot), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<locks::SetSim>(simSlot), service::name::appmgr);
}
void SimLockSubject::changeSimPin()
{
- owner->bus.sendUnicast(std::make_shared<locks::ChangeSimPin>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<locks::ChangeSimPin>(), service::name::appmgr);
}
void SimLockSubject::enableSimPin()
{
- owner->bus.sendUnicast(std::make_shared<locks::EnableSimPin>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<locks::EnableSimPin>(), service::name::appmgr);
}
void SimLockSubject::disableSimPin()
{
- owner->bus.sendUnicast(std::make_shared<locks::DisableSimPin>(), app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<locks::DisableSimPin>(), service::name::appmgr);
}
void SimLockSubject::verifyInput(LockInput inputData)
{
- owner->bus.sendUnicast(std::make_shared<UnLockSimInput>(inputData),
- app::manager::ApplicationManager::ServiceName);
+ owner->bus.sendUnicast(std::make_shared<UnLockSimInput>(inputData), service::name::appmgr);
}
} // namespace locks
M module-apps/apps-common/windows/Dialog.cpp => module-apps/apps-common/windows/Dialog.cpp +1 -1
@@ 3,9 3,9 @@
#include "Dialog.hpp"
#include "DialogMetadataMessage.hpp"
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <i18n/i18n.hpp>
#include <Image.hpp>
+#include <apps-common/Application.hpp>
using namespace gui;
M module-apps/apps-common/windows/OptionWindow.cpp => module-apps/apps-common/windows/OptionWindow.cpp +0 -1
@@ 5,7 5,6 @@
#include "Label.hpp"
#include <i18n/i18n.hpp>
#include <log.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <Style.hpp>
#include <memory>
#include <utility>
M module-services/service-antenna/ServiceAntenna.cpp => module-services/service-antenna/ServiceAntenna.cpp +0 -1
@@ 12,7 12,6 @@
#include <MessageType.hpp>
#include <module-sys/Timers/TimerFactory.hpp>
#include <projdefs.h>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <service-cellular/CellularMessage.hpp>
#include <service-cellular/CellularServiceAPI.hpp>
#include <service-cellular/State.hpp>
M module-services/service-appmgr/CMakeLists.txt => module-services/service-appmgr/CMakeLists.txt +3 -2
@@ 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
M module-services/service-appmgr/Controller.cpp => module-services/service-appmgr/Controller.cpp +13 -13
@@ 3,11 3,11 @@
#include "Controller.hpp"
-#include "ApplicationManager.hpp"
#include "FinishRequest.hpp"
#include "GetAllNotificationsRequest.hpp"
#include <Service/Service.hpp>
+#include <service-appmgr/Constants.hpp>
#include <utility>
@@ 28,13 28,13 @@ namespace app::manager
StartInBackground startInBackground) -> bool
{
auto msg = std::make_shared<app::manager::ApplicationInitialised>(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<app::manager::FinishRequest>(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<app::manager::ActionRequest>(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<SwitchBackRequest> msg) -> bool
{
std::shared_ptr<SwitchBackRequest> switchMsg =
msg ? std::move(msg) : std::make_shared<app::manager::SwitchBackRequest>(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<app::manager::SwitchConfirmation>(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<app::manager::ApplicationCloseRequest>(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<app::manager::CloseConfirmation>(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<app::manager::DisplayLanguageChangeRequest>(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<app::manager::InputLanguageChangeRequest>(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<app::manager::PreventBlockingRequest>(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<app::manager::PowerSaveModeInitRequest>(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<app::manager::GetAllNotificationsRequest>();
- return sender->bus.sendUnicast(std::move(msg), ApplicationManager::ServiceName);
+ return sender->bus.sendUnicast(std::move(msg), service::name::appmgr);
}
} // namespace app::manager
A module-services/service-appmgr/include/service-appmgr/Constants.hpp => module-services/service-appmgr/include/service-appmgr/Constants.hpp +9 -0
@@ 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";
+};
M module-services/service-appmgr/include/service-appmgr/Controller.hpp => module-services/service-appmgr/include/service-appmgr/Controller.hpp +0 -1
@@ 5,7 5,6 @@
#include <service-appmgr/Actions.hpp>
#include <service-appmgr/messages/Message.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <module-sys/Service/Service.hpp>
#include <SwitchData.hpp>
M module-services/service-appmgr/include/service-appmgr/model/ActionsRegistry.hpp => module-services/service-appmgr/include/service-appmgr/model/ActionsRegistry.hpp +2 -1
@@ 42,7 42,8 @@ namespace app::manager
{
Accepted,
Skipped,
- Dropped
+ Dropped,
+ NotHandled
};
class ActionsRegistry
R module-services/service-appmgr/include/service-appmgr/model/ApplicationManager.hpp => module-services/service-appmgr/include/service-appmgr/model/ApplicationManagerCommon.hpp +22 -62
@@ 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<std::unique_ptr<app::ApplicationLauncher>> &&launchers,
- const ApplicationName &_rootApplicationName);
+ ApplicationManagerCommon(const ApplicationName &serviceName,
+ std::vector<std::unique_ptr<app::ApplicationLauncher>> &&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<sys::ResponseMessage>;
+ 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::Settings> 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<sys::ResponseMessage>;
- 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<sys::ResponseMessage>;
void handleStart(StartAllowedMessage *msg);
- auto handleAutoLockGetRequest(GetAutoLockTimeoutRequest *request) -> std::shared_ptr<sys::ResponseMessage>;
- auto handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request) -> std::shared_ptr<sys::ResponseMessage>;
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::Settings> settings;
- std::shared_ptr<sys::phone_modes::Observer> 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<app::manager::ApplicationManager>
- {
- 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
M module-services/service-appmgr/model/ActionsRegistry.cpp => module-services/service-appmgr/model/ActionsRegistry.cpp +2 -0
@@ 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;
R module-services/service-appmgr/model/ApplicationManager.cpp => module-services/service-appmgr/model/ApplicationManagerCommon.cpp +71 -456
@@ 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 <module-services/service-db/agents/settings/SystemSettings.hpp>
#include <module-sys/Timers/TimerFactory.hpp>
#include <module-utils/Utils.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/StartupType.hpp>
#include <service-cellular-api>
#include <service-cellular/CellularMessage.hpp>
@@ 49,7 50,6 @@ namespace app::manager
namespace
{
constexpr auto ApplicationManagerStackDepth = 3072;
- constexpr auto autoLockTimerName = "AutoLockTimer";
} // namespace
ApplicationManagerBase::ApplicationManagerBase(std::vector<std::unique_ptr<app::ApplicationLauncher>> &&launchers)
@@ 116,50 116,25 @@ namespace app::manager
return runningApps;
}
- ApplicationManager::ApplicationManager(const ApplicationName &serviceName,
- std::vector<std::unique_ptr<app::ApplicationLauncher>> &&launchers,
- const ApplicationName &_rootApplicationName)
+ ApplicationManagerCommon::ApplicationManagerCommon(
+ const ApplicationName &serviceName,
+ std::vector<std::unique_ptr<app::ApplicationLauncher>> &&launchers,
+ const ApplicationName &_rootApplicationName)
: Service{serviceName, {}, ApplicationManagerStackDepth},
ApplicationManagerBase(std::move(launchers)), rootApplicationName{_rootApplicationName},
actionsRegistry{[this](ActionEntry &action) { return handleAction(action); }},
- settings(std::make_shared<settings::Settings>()),
- phoneModeObserver(std::make_shared<sys::phone_modes::Observer>()),
- phoneLockHandler(locks::PhoneLockHandler(this, settings)),
- simLockHandler(this), notificationsConfig{phoneModeObserver, settings, phoneLockHandler},
- notificationsHandler{this, notificationsConfig}, notificationProvider{this, notificationsConfig}
+ settings(std::make_shared<settings::Settings>())
{
- 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<bool>(
- 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<bool>(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<bsp::keypad_backlight::State>(utils::getNumericValue<int>(value));
- processKeypadBacklightState(keypadLightState);
- },
- ::settings::SettingsScope::Global);
-
- startBackgroundApplications();
+
bus.sendUnicast(std::make_unique<CheckIfStartAllowedMessage>(), 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<SwitchRequest>(ServiceName, app::name_desktop, window::name::dead_battery, nullptr)
- .get());
+ handleSwitchApplication(std::make_unique<SwitchRequest>(
+ service::name::appmgr, app::name_desktop, window::name::dead_battery, nullptr)
+ .get());
break;
case StartupType::LowBatteryCharging:
handleSwitchApplication(
- std::make_unique<SwitchRequest>(ServiceName, app::name_desktop, window::name::charging_battery, nullptr)
+ std::make_unique<SwitchRequest>(
+ 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<ApplicationName>{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<sys::ResponseMessage>();
}
- 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<gui::PhoneModePopupRequestParams>(phoneMode)});
- });
-
- phoneModeObserver->subscribe(
- [this](sys::phone_modes::Tethering tethering) { handleTetheringChanged(tethering); });
-
- notificationsHandler.registerMessageHandlers();
-
connect(typeid(StartAllowedMessage), [this](sys::Message *request) {
auto msg = static_cast<StartAllowedMessage *>(request);
handleStart(msg);
@@ 282,12 225,6 @@ namespace app::manager
handlePowerSavingModeInit();
return std::make_shared<sys::ResponseMessage>();
});
- connect(typeid(PreventBlockingRequest), [this]([[maybe_unused]] sys::Message *msg) {
- if (!phoneLockHandler.isPhoneLocked()) {
- autoLockTimer.start();
- }
- return std::make_shared<sys::ResponseMessage>();
- });
connect(typeid(SwitchRequest), [this](sys::Message *request) {
auto msg = static_cast<SwitchRequest *>(request);
handleSwitchApplication(msg);
@@ 350,176 287,6 @@ namespace app::manager
connect(typeid(GetCurrentDisplayLanguageRequest), [&](sys::Message *request) {
return std::make_shared<GetCurrentDisplayLanguageResponse>(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<db::NotificationMessage *>(msg);
- notificationProvider.handle(msgl);
- return sys::msgHandled();
- });
- connect(typeid(db::QueryResponse), [&](sys::Message *msg) {
- auto response = static_cast<db::QueryResponse *>(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<locks::UnLockPhoneInput *>(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<GetAutoLockTimeoutRequest *>(request);
- return handleAutoLockGetRequest(req);
- });
- connect(typeid(SetAutoLockTimeoutRequest), [&](sys::Message *request) -> sys::MessagePointer {
- auto req = static_cast<SetAutoLockTimeoutRequest *>(request);
- return handleAutoLockSetRequest(req);
- });
- connect(typeid(locks::ExternalUnLockPhone), [&](sys::Message *request) -> sys::MessagePointer {
- auto data = static_cast<locks::ExternalUnLockPhone *>(request);
- return phoneLockHandler.handleExternalUnlockRequest(data->getInputData());
- });
- connect(typeid(locks::ExternalPhoneLockAvailabilityChange), [&](sys::Message *request) -> sys::MessagePointer {
- auto data = static_cast<locks::ExternalPhoneLockAvailabilityChange *>(request);
- return phoneLockHandler.handleExternalAvailabilityChange(data->getAvailability());
- });
-
- // SimLock connects
- connect(typeid(cellular::msg::notification::SimNeedPin), [&](sys::Message *request) -> sys::MessagePointer {
- auto data = static_cast<cellular::msg::notification::SimNeedPin *>(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<cellular::msg::request::sim::PinUnlock::Response *>(request);
- if (data->retCode) {
- return simLockHandler.handleSimUnlockedMessage();
- }
- return sys::msgNotHandled();
- });
- connect(typeid(locks::UnLockSimInput), [&](sys::Message *request) -> sys::MessagePointer {
- auto msg = static_cast<locks::UnLockSimInput *>(request);
- return simLockHandler.verifySimLockInput(msg->getInputData());
- });
- connect(typeid(cellular::msg::notification::SimNeedPuk), [&](sys::Message *request) -> sys::MessagePointer {
- auto data = static_cast<cellular::msg::notification::SimNeedPuk *>(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<cellular::msg::request::sim::UnblockWithPuk::Response *>(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<cellular::msg::request::sim::ChangePin::Response *>(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<cellular::msg::request::sim::SetPinLock::Response *>(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<cellular::msg::notification::UnhandledCME *>(request);
- if (phoneLockHandler.isPhoneLocked()) {
- simLockHandler.setSimUnlockBlockOnLockedPhone();
- }
- return simLockHandler.handleCMEErrorRequest(data->code);
- });
- connect(typeid(locks::SetSim), [&](sys::Message *request) -> sys::MessagePointer {
- auto data = static_cast<locks::SetSim *>(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<cellular::msg::request::sim::SetActiveSim::Response *>(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<cellular::msg::notification::ModemStateChanged *>(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<gui::SwitchData> &&data,
- std::string targetWindow)
+ void ApplicationManagerCommon::onApplicationSwitch(ApplicationHandle &nextApp,
+ std::unique_ptr<gui::SwitchData> &&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<gui::PhoneModeParams>(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<bool>(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<ApplicationLaunchData *>(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<gui::SwitchData> &&data)
+ void ApplicationManagerCommon::onApplicationSwitchToPrev(ApplicationHandle &previousApp,
+ std::unique_ptr<gui::SwitchData> &&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<db::query::notifications::GetAllResult *>(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<sys::ResponseMessage>
+ auto ApplicationManagerCommon::handleMessageAsAction(sys::Message *request) -> std::shared_ptr<sys::ResponseMessage>
{
auto actionMsg = dynamic_cast<manager::actions::ConvertibleToAction *>(request);
if (!actionMsg) {
@@ 1122,73 816,19 @@ namespace app::manager
return std::make_shared<sys::ResponseMessage>();
}
- 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<unsigned int>(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<sys::ResponseMessage>
- {
- auto intervalValue =
- settings->getValue(settings::SystemProperties::autoLockTimeInSec, settings::SettingsScope::Global);
- const auto interval = std::chrono::seconds{utils::getNumericValue<unsigned int>(intervalValue)};
- return std::make_shared<GetAutoLockTimeoutResponse>(interval);
- }
- auto ApplicationManager::handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request)
- -> std::shared_ptr<sys::ResponseMessage>
- {
- auto interval = request->getValue();
- settings->setValue(settings::SystemProperties::autoLockTimeInSec,
- utils::to_string(interval.count()),
- settings::SettingsScope::Global);
- autoLockTimer.restart(interval);
- return std::make_shared<sys::ResponseMessage>();
- }
-
- void ApplicationManager::inputLanguageChanged(std::string value)
+ void ApplicationManagerCommon::inputLanguageChanged(std::string value)
{
utils::setInputLanguage(value);
}
- auto ApplicationManager::handleDOMRequest(sys::Message *request) -> std::shared_ptr<sys::ResponseMessage>
+ auto ApplicationManagerCommon::handleDOMRequest(sys::Message *request) -> std::shared_ptr<sys::ResponseMessage>
{
auto app = getFocusedApplication();
if (app != nullptr) {
@@ 1200,33 840,8 @@ namespace app::manager
return std::make_shared<sys::ResponseMessage>(sys::ReturnCodes::Unresolved);
}
- auto ApplicationManager::handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer
+ auto ApplicationManagerCommon::handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer
{
- if (auto msg = dynamic_cast<sdesktop::developerMode::DeveloperModeRequest *>(request)) {
- if (dynamic_cast<sdesktop::developerMode::ScreenlockCheckEvent *>(msg->event.get())) {
- auto response = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(
- std::make_unique<sdesktop::developerMode::ScreenlockCheckEvent>(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<sevm::KeypadBacklightMessage>(action), service::name::evt_manager);
- }
+ };
} // namespace app::manager
M module-services/service-cellular/CellularRequestHandler.cpp => module-services/service-cellular/CellularRequestHandler.cpp +10 -10
@@ 22,7 22,7 @@
#include "service-cellular/requests/CallWaitingRequest.hpp"
#include "service-cellular/requests/RejectRequest.hpp"
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <module-cellular/at/response.hpp>
@@ 42,7 42,7 @@ void CellularRequestHandler::handle(cellular::ImeiRequest &request, at::Result &
}
auto msg = std::make_shared<CellularMMIResultMessage>(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<CellularNoSimNotification>(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<CellularNotAnEmergencyNotification>(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<CellularMMIResultMessage>(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<CellularMMIResultMessage>(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<CellularMMIResultMessage>(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<CellularMMIResultMessage>(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<CellularMMIResultMessage>(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<CellularMMIResultMessage>(result ? MMIResultParams::MMIResult::Success
: MMIResultParams::MMIResult::Failed);
- cellular.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName);
+ cellular.bus.sendUnicast(msg, ::service::name::appmgr);
}
M module-services/service-cellular/CellularUrcHandler.cpp => module-services/service-cellular/CellularUrcHandler.cpp +3 -2
@@ 9,6 9,7 @@
#include <service-antenna/AntennaServiceAPI.hpp>
#include <service-evtmgr/Constants.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/Controller.hpp>
#include <service-time/Constants.hpp>
@@ 79,7 80,7 @@ void CellularUrcHandler::Handle(Cusd &urc)
cellularService.ussdState = ussd::State::pullResponseReceived;
cellularService.setUSSDTimer();
auto msg = std::make_shared<CellularMMIResponseMessage>(*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<CellularMMIPushMessage>(*message);
- cellularService.bus.sendUnicast(msg, app::manager::ApplicationManager::ServiceName);
+ cellularService.bus.sendUnicast(msg, service::name::appmgr);
}
urc.setHandled(true);
M module-services/service-cellular/ServiceCellular.cpp => module-services/service-cellular/ServiceCellular.cpp +2 -2
@@ 63,6 63,7 @@
#include <service-antenna/AntennaMessage.hpp>
#include <service-antenna/AntennaServiceAPI.hpp>
#include <service-antenna/ServiceAntenna.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/Controller.hpp>
#include <service-db/DBServiceAPI.hpp>
#include <service-db/DBNotificationMessage.hpp>
@@ 72,7 73,6 @@
#include <service-evtmgr/EVMessages.hpp>
#include <service-desktop/DesktopMessages.hpp>
#include <service-desktop/DeveloperModeMessage.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
#include <service-time/service-time/TimeMessage.hpp>
#include <task.h>
#include <ucs2/UCS2.hpp>
@@ 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<CellularCallRejectedByOfflineNotification>(),
- app::manager::ApplicationManager::ServiceName);
+ ::service::name::appmgr);
return std::make_shared<CellularResponseMessage>(true);
}
M module-services/service-cellular/src/ServiceCellularPriv.cpp => module-services/service-cellular/src/ServiceCellularPriv.cpp +2 -2
@@ 15,7 15,7 @@
#include <at/ATFactory.hpp>
#include <ucs2/UCS2.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#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<CellularSMSRejectedByOfflineNotification>(),
- app::manager::ApplicationManager::ServiceName);
+ ::service::name::appmgr);
ret = true;
}
return ret;
M module-services/service-desktop/ServiceDesktop.cpp => module-services/service-desktop/ServiceDesktop.cpp +4 -4
@@ 23,7 23,8 @@
#include <module-sys/SystemManager/SystemManager.hpp>
#include <module-sys/Timers/TimerFactory.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <locks/data/PhoneLockMessages.hpp>
+#include <service-appmgr/Constants.hpp>
#include <module-services/service-db/agents/settings/SystemSettings.hpp>
#include <module-sys/SystemManager/Constants.hpp>
#include <module-sys/SystemManager/messages/TetheringStateRequest.hpp>
@@ 159,7 160,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler()
if (usbSecurityModel->isSecurityEnabled()) {
LOG_INFO("Endpoint security enabled, requesting passcode");
- bus.sendUnicast(std::make_shared<locks::UnlockPhone>(), app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<locks::UnlockPhone>(), 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<locks::CancelUnlockPhone>(),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<locks::CancelUnlockPhone>(), service::name::appmgr);
}
bus.sendUnicast(std::make_shared<sys::TetheringStateRequest>(sys::phone_modes::Tethering::Off),
service::name::system_manager);
M module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp => module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp +1 -0
@@ 26,6 26,7 @@
#include <service-appmgr/Controller.hpp>
#include <ctime>
+#include <locks/data/PhoneLockMessages.hpp>
namespace parserFSM
{
M module-services/service-desktop/endpoints/developerMode/Mode/UI_Helper.cpp => module-services/service-desktop/endpoints/developerMode/Mode/UI_Helper.cpp +2 -2
@@ 6,7 6,7 @@
#include "service-desktop/Constants.hpp"
#include "service-desktop/DeveloperModeMessage.hpp"
#include <variant>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/messages/DOMRequest.hpp>
namespace parserFSM
@@ 33,7 33,7 @@ namespace parserFSM
owner->bus.sendUnicast(
std::make_shared<app::manager::DOMRequest>(service::name::service_desktop,
std::make_unique<sdesktop::Event>(std::move(event))),
- app::manager::ApplicationManager::ServiceName);
+ service::name::appmgr);
return {sent::delayed, std::nullopt};
}
return {sent::no, std::nullopt};
M module-services/service-desktop/endpoints/security/SecurityEndpointHelper.cpp => module-services/service-desktop/endpoints/security/SecurityEndpointHelper.cpp +3 -4
@@ 3,7 3,7 @@
#include "SecurityEndpointHelper.hpp"
#include <parser/ParserUtils.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/messages/PreventBlockingRequest.hpp>
#include <service-desktop/service-desktop/ServiceDesktop.hpp>
#include <apps-common/locks/data/PhoneLockMessages.hpp>
@@ 73,9 73,8 @@ auto SecurityEndpointHelper::processConfiguration(Context &context) -> http::Cod
if (passCode.size() == PasscodeLength) {
try {
auto msg = std::make_shared<locks::ExternalUnLockPhone>(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");
M module-sys/SystemManager/SystemManager.cpp => module-sys/SystemManager/SystemManager.cpp +15 -14
@@ 20,7 20,7 @@
#include <service-desktop/service-desktop/Constants.hpp>
#include <service-cellular/CellularServiceAPI.hpp>
#include <service-cellular/CellularMessage.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-appmgr/Controller.hpp>
#include "messages/CpuFrequencyMessage.hpp"
#include "messages/DeviceRegistrationMessage.hpp"
@@ 34,6 34,10 @@
#include "Timers/TimerFactory.hpp"
#include <service-appmgr/StartupType.hpp>
#include <purefs/vfs_subsystem.hpp>
+#include <service-gui/Common.hpp>
+#include <service-db/DBServiceName.hpp>
+#include <module-gui/gui/Common.hpp>
+#include <service-eink/Common.hpp>
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<CriticalBatteryLevelNotification>(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<CriticalBatteryLevelNotification>(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::StartAllowedMessage>(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::StartAllowedMessage>(app::manager::StartupType::LowBattery),
- app::manager::ApplicationManager::ServiceName);
+ service::name::appmgr);
break;
case Store::Battery::LevelState::CriticalCharging:
bus.sendUnicast(
std::make_unique<app::manager::StartAllowedMessage>(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<TetheringPhoneModeChangeProhibitedMessage>(),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<TetheringPhoneModeChangeProhibitedMessage>(), 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<TetheringQuestionRequest>(),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<TetheringQuestionRequest>(), service::name::appmgr);
}
else {
if (const auto tetheringChanged = phoneModeSubject->setTetheringMode(phone_modes::Tethering::Off);
!tetheringChanged) {
- bus.sendUnicast(std::make_shared<TetheringQuestionAbort>(),
- app::manager::ApplicationManager::ServiceName);
+ bus.sendUnicast(std::make_shared<TetheringQuestionAbort>(), service::name::appmgr);
}
else {
// Turned on, disabling...
M products/BellHybrid/BellHybridMain.cpp => products/BellHybrid/BellHybridMain.cpp +3 -2
@@ 9,10 9,11 @@
#include <application-bell-settings/ApplicationBellSettings.hpp>
// services
+#include <appmgr/ApplicationManager.hpp>
#include <evtmgr/EventManager.hpp>
#include <module-services/service-eink/ServiceEink.hpp>
#include <Service/ServiceCreator.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-audio/ServiceAudio.hpp>
#include <service-bluetooth/ServiceBluetooth.hpp>
#include <service-db/ServiceDB.hpp>
@@ 98,7 99,7 @@ int main()
// start application manager
return sysmgr->RunSystemService(
std::make_shared<app::manager::ApplicationManager>(
- app::manager::ApplicationManager::ServiceName, std::move(applications), app::applicationBellName),
+ service::name::appmgr, std::move(applications), app::applicationBellName),
sysmgr.get());
});
M products/BellHybrid/CMakeLists.txt => products/BellHybrid/CMakeLists.txt +1 -0
@@ 40,6 40,7 @@ target_link_libraries(BellHybrid
application-bell-main
application-bell-settings
application-music-player
+ appmgr
evtmgr
messagetype
module-apps
M products/BellHybrid/services/CMakeLists.txt => products/BellHybrid/services/CMakeLists.txt +1 -0
@@ 1,1 1,2 @@
add_subdirectory(evtmgr)
+add_subdirectory(appmgr)
A products/BellHybrid/services/appmgr/ApplicationManager.cpp => products/BellHybrid/services/appmgr/ApplicationManager.cpp +26 -0
@@ 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 <appmgr/ApplicationManager.hpp>
+
+#include <application-onboarding/ApplicationOnBoarding.hpp>
+
+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
A products/BellHybrid/services/appmgr/CMakeLists.txt => products/BellHybrid/services/appmgr/CMakeLists.txt +19 -0
@@ 0,0 1,19 @@
+add_library(appmgr STATIC)
+
+target_sources(appmgr
+ PRIVATE
+ ApplicationManager.cpp
+ PUBLIC
+ include/appmgr/ApplicationManager.hpp
+)
+
+target_include_directories(appmgr
+ PUBLIC
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+
+target_link_libraries(appmgr
+ PRIVATE
+ module-apps
+ service-appmgr
+)
A products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp => products/BellHybrid/services/appmgr/include/appmgr/ApplicationManager.hpp +25 -0
@@ 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 <service-appmgr/model/ApplicationManagerCommon.hpp>
+
+namespace app::manager
+{
+ class ApplicationManager : public ApplicationManagerCommon
+ {
+ public:
+ ApplicationManager(const ApplicationName &serviceName,
+ std::vector<std::unique_ptr<app::ApplicationLauncher>> &&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
M products/PurePhone/CMakeLists.txt => products/PurePhone/CMakeLists.txt +1 -0
@@ 55,6 55,7 @@ target_link_libraries(PurePhone
application-phonebook
application-settings
application-special-input
+ appmgr
evtmgr
messagetype
module-apps
M products/PurePhone/PurePhoneMain.cpp => products/PurePhone/PurePhoneMain.cpp +5 -5
@@ 22,8 22,9 @@
#include <application-onboarding/ApplicationOnBoarding.hpp>
// services
+#include <appmgr/ApplicationManager.hpp>
#include <evtmgr/EventManager.hpp>
-#include <service-appmgr/model/ApplicationManager.hpp>
+#include <service-appmgr/Constants.hpp>
#include <service-audio/ServiceAudio.hpp>
#include <service-bluetooth/ServiceBluetooth.hpp>
#include <service-db/ServiceDB.hpp>
@@ 169,10 170,9 @@ int main()
applications.push_back(app::CreateLauncher<app::ApplicationOnBoarding>(app::name_onboarding));
#endif
// start application manager
- return sysmgr->RunSystemService(
- std::make_shared<app::manager::ApplicationManager>(
- app::manager::ApplicationManager::ServiceName, std::move(applications), app::name_desktop),
- sysmgr.get());
+ return sysmgr->RunSystemService(std::make_shared<app::manager::ApplicationManager>(
+ service::name::appmgr, std::move(applications), app::name_desktop),
+ sysmgr.get());
});
LOG_PRINTF("Launching PurePhone \n");
M products/PurePhone/services/CMakeLists.txt => products/PurePhone/services/CMakeLists.txt +1 -0
@@ 1,1 1,2 @@
add_subdirectory(evtmgr)
+add_subdirectory(appmgr)
A products/PurePhone/services/appmgr/ApplicationManager.cpp => products/PurePhone/services/appmgr/ApplicationManager.cpp +478 -0
@@ 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 <appmgr/ApplicationManager.hpp>
+
+#include <application-onboarding/ApplicationOnBoarding.hpp>
+#include <application-onboarding/data/OnBoardingMessages.hpp>
+#include <application-special-input/ApplicationSpecialInput.hpp>
+#include <apps-common/popups/data/PhoneModeParams.hpp>
+#include <apps-common/popups/data/PopupRequestParams.hpp>
+#include <module-db/queries/notifications/QueryNotificationsGetAll.hpp>
+#include <module-sys/SystemManager/messages/TetheringPhoneModeChangeProhibitedMessage.hpp>
+#include <module-sys/SystemManager/messages/TetheringQuestionRequest.hpp>
+#include <module-sys/Timers/TimerFactory.hpp>
+#include <service-appmgr/include/service-appmgr/messages/AutoLockRequests.hpp>
+#include <service-appmgr/messages/GetAllNotificationsRequest.hpp>
+#include <service-cellular/service-cellular/CellularMessage.hpp>
+#include <service-db/agents/settings/SystemSettings.hpp>
+#include <service-db/service-db/DBNotificationMessage.hpp>
+#include <service-desktop/Constants.hpp>
+#include <service-desktop/DesktopMessages.hpp>
+#include <service-desktop/DeveloperModeMessage.hpp>
+#include <service-evtmgr/EVMessages.hpp>
+#include <service-evtmgr/service-evtmgr/Constants.hpp>
+#include <service-evtmgr/service-evtmgr/torch.hpp>
+
+namespace app::manager
+{
+ namespace
+ {
+ constexpr auto autoLockTimerName = "AutoLockTimer";
+ } // namespace
+
+ ApplicationManager::ApplicationManager(const ApplicationName &serviceName,
+ std::vector<std::unique_ptr<app::ApplicationLauncher>> &&launchers,
+ const ApplicationName &_rootApplicationName)
+ : ApplicationManagerCommon(serviceName, std::move(launchers), _rootApplicationName),
+ phoneModeObserver(std::make_shared<sys::phone_modes::Observer>()),
+ 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<bool>(
+ 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<bool>(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<bsp::keypad_backlight::State>(utils::getNumericValue<int>(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<sevm::KeypadBacklightMessage>(action), service::name::evt_manager);
+ }
+
+ void ApplicationManager::startBackgroundApplications()
+ {
+ for (const auto &name : std::vector<ApplicationName>{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<gui::PhoneModePopupRequestParams>(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<sys::ResponseMessage>();
+ });
+ connect(typeid(GetAllNotificationsRequest), [&](sys::Message *request) {
+ notificationProvider.requestNotSeenNotifications();
+ notificationProvider.send();
+ return sys::msgHandled();
+ });
+ connect(typeid(db::NotificationMessage), [&](sys::Message *msg) {
+ auto msgl = static_cast<db::NotificationMessage *>(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<locks::UnLockPhoneInput *>(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<GetAutoLockTimeoutRequest *>(request);
+ return handleAutoLockGetRequest(req);
+ });
+ connect(typeid(SetAutoLockTimeoutRequest), [&](sys::Message *request) -> sys::MessagePointer {
+ auto req = static_cast<SetAutoLockTimeoutRequest *>(request);
+ return handleAutoLockSetRequest(req);
+ });
+ connect(typeid(locks::ExternalUnLockPhone), [&](sys::Message *request) -> sys::MessagePointer {
+ auto data = static_cast<locks::ExternalUnLockPhone *>(request);
+ return phoneLockHandler.handleExternalUnlockRequest(data->getInputData());
+ });
+ connect(typeid(locks::ExternalPhoneLockAvailabilityChange), [&](sys::Message *request) -> sys::MessagePointer {
+ auto data = static_cast<locks::ExternalPhoneLockAvailabilityChange *>(request);
+ return phoneLockHandler.handleExternalAvailabilityChange(data->getAvailability());
+ });
+
+ // SimLock connects
+ connect(typeid(cellular::msg::notification::SimNeedPin), [&](sys::Message *request) -> sys::MessagePointer {
+ auto data = static_cast<cellular::msg::notification::SimNeedPin *>(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<cellular::msg::request::sim::PinUnlock::Response *>(request);
+ if (data->retCode) {
+ return simLockHandler.handleSimUnlockedMessage();
+ }
+ return sys::msgNotHandled();
+ });
+ connect(typeid(locks::UnLockSimInput), [&](sys::Message *request) -> sys::MessagePointer {
+ auto msg = static_cast<locks::UnLockSimInput *>(request);
+ return simLockHandler.verifySimLockInput(msg->getInputData());
+ });
+ connect(typeid(cellular::msg::notification::SimNeedPuk), [&](sys::Message *request) -> sys::MessagePointer {
+ auto data = static_cast<cellular::msg::notification::SimNeedPuk *>(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<cellular::msg::request::sim::UnblockWithPuk::Response *>(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<cellular::msg::request::sim::ChangePin::Response *>(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<cellular::msg::request::sim::SetPinLock::Response *>(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<cellular::msg::notification::UnhandledCME *>(request);
+ if (phoneLockHandler.isPhoneLocked()) {
+ simLockHandler.setSimUnlockBlockOnLockedPhone();
+ }
+ return simLockHandler.handleCMEErrorRequest(data->code);
+ });
+ connect(typeid(locks::SetSim), [&](sys::Message *request) -> sys::MessagePointer {
+ auto data = static_cast<locks::SetSim *>(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<cellular::msg::request::sim::SetActiveSim::Response *>(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<cellular::msg::notification::ModemStateChanged *>(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<db::QueryResponse *>(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<gui::PhoneModeParams>(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<sys::ResponseMessage>
+ {
+ auto intervalValue =
+ settings->getValue(settings::SystemProperties::autoLockTimeInSec, settings::SettingsScope::Global);
+ const auto interval = std::chrono::seconds{utils::getNumericValue<unsigned int>(intervalValue)};
+ return std::make_shared<GetAutoLockTimeoutResponse>(interval);
+ }
+
+ auto ApplicationManager::handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request)
+ -> std::shared_ptr<sys::ResponseMessage>
+ {
+ auto interval = request->getValue();
+ settings->setValue(settings::SystemProperties::autoLockTimeInSec,
+ utils::to_string(interval.count()),
+ settings::SettingsScope::Global);
+ autoLockTimer.restart(interval);
+ return std::make_shared<sys::ResponseMessage>();
+ }
+
+ auto ApplicationManager::handleDeveloperModeRequest(sys::Message *request) -> sys::MessagePointer
+ {
+ if (auto msg = dynamic_cast<sdesktop::developerMode::DeveloperModeRequest *>(request)) {
+ if (dynamic_cast<sdesktop::developerMode::ScreenlockCheckEvent *>(msg->event.get())) {
+ auto response = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(
+ std::make_unique<sdesktop::developerMode::ScreenlockCheckEvent>(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<unsigned int>(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<db::query::notifications::GetAllResult *>(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
A products/PurePhone/services/appmgr/CMakeLists.txt => products/PurePhone/services/appmgr/CMakeLists.txt +27 -0
@@ 0,0 1,27 @@
+add_library(appmgr STATIC)
+
+target_sources(appmgr
+ PRIVATE
+ ApplicationManager.cpp
+ PUBLIC
+ include/appmgr/ApplicationManager.hpp
+)
+
+target_include_directories(appmgr
+ PUBLIC
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+
+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
+)
A products/PurePhone/services/appmgr/include/appmgr/ApplicationManager.hpp => products/PurePhone/services/appmgr/include/appmgr/ApplicationManager.hpp +56 -0
@@ 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 <service-appmgr/model/ApplicationManagerCommon.hpp>
+
+namespace app::manager
+{
+ class ApplicationManager : public ApplicationManagerCommon
+ {
+ public:
+ ApplicationManager(const ApplicationName &serviceName,
+ std::vector<std::unique_ptr<app::ApplicationLauncher>> &&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<sys::ResponseMessage>;
+ auto handleAutoLockSetRequest(SetAutoLockTimeoutRequest *request) -> std::shared_ptr<sys::ResponseMessage>;
+ 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<sys::phone_modes::Observer> 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