19 files changed, 96 insertions(+), 95 deletions(-)

M module-apps/application-calendar/include/application-calendar/ApplicationCalendar.hpp
M module-apps/application-call/include/application-call/ApplicationCall.hpp
M module-apps/apps-common/Application.hpp
M module-apps/apps-common/ApplicationLauncher.hpp
M module-services/service-appmgr/model/ApplicationManagerCommon.cpp
M module-services/service-desktop/ServiceDesktop.cpp
M module-services/service-desktop/endpoints/backup/BackupRestore.cpp
M module-services/service-desktop/endpoints/factoryReset/FactoryReset.cpp
M module-services/service-desktop/endpoints/update/UpdateHelper.cpp
M module-services/service-evtmgr/EventManager.cpp
M module-services/service-evtmgr/WorkerEvent.cpp
M module-services/service-gui/ServiceGUI.cpp
M module-sys/CMakeLists.txt
R module-sys/SystemManager/{SystemManager => SystemManagerCommon}.cpp
R module-sys/SystemManager/{SystemManager => SystemManagerCommon}.hpp
M products/BellHybrid/BellHybridMain.cpp
M products/PurePhone/PurePhoneMain.cpp
M products/PurePhone/services/evtmgr/EventManager.cpp
M products/PurePhone/test/test-settings/test-service-db-settings-api.cpp

@@ 5,7 5,7 @@
 
 #include "Application.hpp"
 #include "Service/Message.hpp"
-#include "SystemManager/SystemManager.hpp"
+#include <SystemManager/SystemManagerCommon.hpp>
 
 namespace app
 {

@@ 11,7 11,7 @@
 #include <service-evtmgr/Constants.hpp>
 #include <service-evtmgr/EVMessages.hpp>
 #include <Service/Message.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 
 namespace app
 {

@@ 13,7 13,7 @@
 #include "Service/Service.hpp" // for Service
 #include "Timers/TimerHandle.hpp"
 #include "SwitchData.hpp"                  // for SwitchData
-#include "SystemManager/SystemManager.hpp" // for SystemManager
+#include <SystemManager/SystemManagerCommon.hpp>
 #include "bsp/keyboard/key_codes.hpp"      // for bsp
 #include "gui/Common.hpp"                  // for ShowMode
 #include "projdefs.h"                      // for pdMS_TO_TICKS

@@ 87,7 87,7 @@ namespace app
             parent = (caller == nullptr ? "" : caller->GetName());
             handle = std::make_shared<T>(name, parent, mode);
             setAutoLockPolicy();
-            return sys::SystemManager::RunApplication(handle, caller);
+            return sys::SystemManagerCommon::RunApplication(handle, caller);
         }
 
         bool runBackground(sys::phone_modes::PhoneMode mode, sys::Service *caller) override


@@ 95,7 95,7 @@ namespace app
             parent = (caller == nullptr ? "" : caller->GetName());
             handle = std::make_shared<T>(name, parent, mode, true);
             setAutoLockPolicy();
-            return sys::SystemManager::RunApplication(handle, caller);
+            return sys::SystemManagerCommon::RunApplication(handle, caller);
         }
     };
 

@@ 12,7 12,7 @@
 
 #include <Common.hpp>
 #include <Service/Message.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <SystemManager/messages/SystemManagerMessage.hpp>
 #include <SystemManager/messages/TetheringPhoneModeChangeProhibitedMessage.hpp>
 #include <SystemManager/messages/TetheringQuestionRequest.hpp>


@@ 173,8 173,8 @@ namespace app::manager
 
     void ApplicationManagerCommon::suspendSystemServices()
     {
-        sys::SystemManager::SuspendService(service::name::gui, this);
-        sys::SystemManager::SuspendService(service::name::eink, this);
+        sys::SystemManagerCommon::SuspendService(service::name::gui, this);
+        sys::SystemManagerCommon::SuspendService(service::name::eink, this);
     }
 
     sys::ReturnCodes ApplicationManagerCommon::DeinitHandler()


@@ 307,8 307,8 @@ namespace app::manager
 
         switch (mode) {
         case sys::ServicePowerMode ::Active:
-            sys::SystemManager::ResumeService(service::name::eink, this);
-            sys::SystemManager::ResumeService(service::name::gui, this);
+            sys::SystemManagerCommon::ResumeService(service::name::eink, this);
+            sys::SystemManagerCommon::ResumeService(service::name::gui, this);
             break;
         case sys::ServicePowerMode ::SuspendToRAM:
             [[fallthrough]];


@@ 376,7 376,7 @@ namespace app::manager
             return;
         }
 
-        if (sys::SystemManager::DestroyApplication(application->name(), this)) {
+        if (sys::SystemManagerCommon::DestroyApplication(application->name(), this)) {
             LOG_INFO("Application %s closed", application->name().c_str());
         }
         else {

@@ 20,7 20,7 @@
 #include <service-evtmgr/EventManagerCommon.hpp>
 #include <service-evtmgr/EVMessages.hpp>
 #include <purefs/filesystem_paths.hpp>
-#include <module-sys/SystemManager/SystemManager.hpp>
+#include <module-sys/SystemManager/SystemManagerCommon.hpp>
 #include <module-sys/Timers/TimerFactory.hpp>
 
 #include <locks/data/PhoneLockMessages.hpp>


@@ 132,7 132,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler()
 
             backupRestoreStatus.state = OperationState::Stopped;
             if (backupRestoreStatus.lastOperationResult == true) {
-                sys::SystemManager::Reboot(this);
+                sys::SystemManagerCommon::Reboot(this);
             }
             else {
                 LOG_ERROR("Restore failed");

@@ 3,7 3,7 @@
 
 #include "BackupRestore.hpp"
 
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <log.hpp>
 #include <microtar.hpp>
 #include <purefs/filesystem_paths.hpp>


@@ 136,7 136,7 @@ bool BackupRestore::RestoreUserFiles(sys::Service *ownerService, const std::file
         return false;
     }
 
-    if (sys::SystemManager::Restore(ownerService) == false) {
+    if (sys::SystemManagerCommon::Restore(ownerService) == false) {
         LOG_ERROR("Can't enter update system state");
         return false;
     }

@@ 2,7 2,7 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "FactoryReset.hpp"
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <log.hpp>
 #include <service-db/DBServiceName.hpp>
 #include <Utils.hpp>


@@ 51,13 51,13 @@ namespace FactoryReset
         if (ownerService != nullptr) {
             LOG_INFO("Closing ServiceDB...");
             std::string dbServiceName = service::name::db;
-            sys::SystemManager::DestroySystemService(dbServiceName, ownerService);
+            sys::SystemManagerCommon::DestroySystemService(dbServiceName, ownerService);
         }
 
         DeleteSelectedUserFiles(userOSPath);
 
         LOG_INFO("Rebooting...");
-        sys::SystemManager::Reboot(ownerService);
+        sys::SystemManagerCommon::Reboot(ownerService);
         return true;
     }
 

@@ 3,7 3,7 @@
 
 #include "UpdateHelper.hpp"
 #include <log.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <purefs/filesystem_paths.hpp>
 
 #include <filesystem>


@@ 29,7 29,7 @@ namespace parserFSM
             return {sent::no, endpoint::ResponseContext{.status = http::Code::NotFound}};
         }
 
-        if (sys::SystemManager::RebootToUpdate(owner, sys::UpdateReason::Update)) {
+        if (sys::SystemManagerCommon::RebootToUpdate(owner, sys::UpdateReason::Update)) {
             return {sent::no, endpoint::ResponseContext{.status = http::Code::NoContent}};
         }
 

@@ 15,7 15,7 @@
 #include <Service/Worker.hpp>
 #include <Timers/TimerFactory.hpp>
 #include <SystemManager/Constants.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <bsp/common.hpp>
 #include <bsp/rtc/rtc.hpp>
 #include <bsp/battery-charger/battery_charger.hpp>

@@ 29,7 29,7 @@
 #include <service-audio/AudioMessage.hpp>
 #include <service-desktop/Constants.hpp>
 #include <service-desktop/DesktopMessages.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <SystemManager/messages/SentinelRegistrationMessage.hpp>
 
 extern "C"

@@ 18,7 18,7 @@
 #include <service-eink/messages/EinkMessage.hpp>
 #include <service-eink/messages/PrepareDisplayEarlyRequest.hpp>
 #include <Timers/TimerFactory.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 
 #include <gsl/util>
 #include <purefs/filesystem_paths.hpp>

@@ 18,7 18,7 @@ set(SOURCES
         ${CMAKE_CURRENT_SOURCE_DIR}/Service/CpuSentinel.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/PhoneModes/Subject.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/PhoneModes/Observer.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/SystemManager/SystemManager.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/SystemManager/SystemManagerCommon.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/SystemManager/DependencyGraph.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/SystemManager/PowerManager.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/SystemManager/CpuStatistics.cpp

@@ 1,7 1,7 @@
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
-#include "SystemManager.hpp"
+#include "SystemManagerCommon.hpp"
 
 #include "DependencyGraph.hpp"
 #include "graph/TopologicalSort.hpp"


@@ 91,13 91,13 @@ namespace sys
     using namespace std;
     using namespace sys;
 
-    void SystemManager::set(enum State state)
+    void SystemManagerCommon::set(enum State state)
     {
         LOG_DEBUG("System manager state: [%s] -> [%s]", c_str(this->state), c_str(state));
         this->state = state;
     }
 
-    SystemManager::SystemManager(std::vector<std::unique_ptr<BaseServiceCreator>> &&creators)
+    SystemManagerCommon::SystemManagerCommon(std::vector<std::unique_ptr<BaseServiceCreator>> &&creators)
         : Service(service::name::system_manager, "", systemManagerStack), systemServiceCreators{std::move(creators)}
     {
         // Specify list of channels which System Manager is registered to


@@ 108,12 108,12 @@ namespace sys
             });
     }
 
-    SystemManager::~SystemManager()
+    SystemManagerCommon::~SystemManagerCommon()
     {
         LOG_DEBUG("%s", (GetName() + ":destructor").c_str());
     }
 
-    void SystemManager::Run()
+    void SystemManagerCommon::Run()
     {
         initialize();
 


@@ 170,7 170,7 @@ namespace sys
         }
     }
 
-    void SystemManager::initialize()
+    void SystemManagerCommon::initialize()
     {
         utils::time::Scoped timer{"Initialize"};
         InitHandler();


@@ 184,7 184,7 @@ namespace sys
         }
     }
 
-    void SystemManager::StartSystemServices()
+    void SystemManagerCommon::StartSystemServices()
     {
         DependencyGraph depGraph{graph::nodesFrom(systemServiceCreators), std::make_unique<graph::TopologicalSort>()};
         const auto &sortedServices = [&depGraph]() {


@@ 207,7 207,7 @@ namespace sys
         postStartRoutine();
     }
 
-    void SystemManager::StartSystem(InitFunction sysInit, InitFunction appSpaceInit)
+    void SystemManagerCommon::StartSystem(InitFunction sysInit, InitFunction appSpaceInit)
     {
         powerManager     = std::make_unique<PowerManager>();
         cpuStatistics    = std::make_unique<CpuStatistics>();


@@ 225,13 225,13 @@ namespace sys
         cpuStatisticsTimer.start();
     }
 
-    bool SystemManager::CloseSystem(Service *s)
+    bool SystemManagerCommon::CloseSystem(Service *s)
     {
         s->bus.sendUnicast(std::make_shared<SystemManagerCmd>(Code::CloseSystem), service::name::system_manager);
         return true;
     }
 
-    bool SystemManager::Restore(Service *s)
+    bool SystemManagerCommon::Restore(Service *s)
     {
         LOG_DEBUG("trying to enter restore state");
         auto ret = s->bus.sendUnicastSync(std::make_shared<SystemManagerCmd>(Code::Restore),


@@ 243,20 243,20 @@ namespace sys
         return true;
     }
 
-    bool SystemManager::Reboot(Service *s)
+    bool SystemManagerCommon::Reboot(Service *s)
     {
         s->bus.sendUnicast(std::make_shared<SystemManagerCmd>(Code::Reboot), service::name::system_manager);
         return true;
     }
 
-    bool SystemManager::RebootToUpdate(Service *s, UpdateReason updateReason)
+    bool SystemManagerCommon::RebootToUpdate(Service *s, UpdateReason updateReason)
     {
         s->bus.sendUnicast(std::make_shared<SystemManagerCmd>(Code::RebootToUpdate, CloseReason::Reboot, updateReason),
                            service::name::system_manager);
         return true;
     }
 
-    bool SystemManager::SuspendService(const std::string &name, sys::Service *caller)
+    bool SystemManagerCommon::SuspendService(const std::string &name, sys::Service *caller)
     {
         auto ret = caller->bus.sendUnicastSync(
             std::make_shared<SystemMessage>(SystemMessageType::SwitchPowerMode, ServicePowerMode::SuspendToRAM),


@@ 270,7 270,7 @@ namespace sys
         return true;
     }
 
-    bool SystemManager::ResumeService(const std::string &name, sys::Service *caller)
+    bool SystemManagerCommon::ResumeService(const std::string &name, sys::Service *caller)
     {
         auto ret = caller->bus.sendUnicastSync(
             std::make_shared<SystemMessage>(SystemMessageType::SwitchPowerMode, ServicePowerMode::Active), name, 1000);


@@ 282,7 282,7 @@ namespace sys
         return true;
     }
 
-    bool SystemManager::RunService(std::shared_ptr<Service> service, Service *caller, TickType_t timeout)
+    bool SystemManagerCommon::RunService(std::shared_ptr<Service> service, Service *caller, TickType_t timeout)
     {
         service->StartService();
 


@@ 296,7 296,7 @@ namespace sys
         return false;
     }
 
-    bool SystemManager::RunSystemService(std::shared_ptr<Service> service, Service *caller, TickType_t timeout)
+    bool SystemManagerCommon::RunSystemService(std::shared_ptr<Service> service, Service *caller, TickType_t timeout)
     {
         CriticalSection::Enter();
         servicesList.push_back(service);


@@ 305,7 305,7 @@ namespace sys
         return RunService(std::move(service), caller, timeout);
     }
 
-    bool SystemManager::RunApplication(std::shared_ptr<app::Application> app, Service *caller, TickType_t timeout)
+    bool SystemManagerCommon::RunApplication(std::shared_ptr<app::Application> app, Service *caller, TickType_t timeout)
     {
         CriticalSection::Enter();
         applicationsList.push_back(app);


@@ 314,7 314,7 @@ namespace sys
         return RunService(std::move(app), caller, timeout);
     }
 
-    bool SystemManager::RequestServiceClose(const std::string &name, Service *caller, TickType_t timeout)
+    bool SystemManagerCommon::RequestServiceClose(const std::string &name, Service *caller, TickType_t timeout)
     {
         auto msg  = std::make_shared<SystemMessage>(SystemMessageType::Exit);
         auto ret  = caller->bus.sendUnicastSync(msg, name, timeout);


@@ 331,7 331,7 @@ namespace sys
         return true;
     }
 
-    template <typename T> void SystemManager::DestroyServices(const T &whitelist)
+    template <typename T> void SystemManagerCommon::DestroyServices(const T &whitelist)
     {
         cpp_freertos::LockGuard lck(serviceDestroyMutex);
         for (auto service = servicesList.begin(); service != servicesList.end();) {


@@ 349,7 349,7 @@ namespace sys
         }
     }
 
-    bool SystemManager::DestroySystemService(const std::string &name, Service *caller)
+    bool SystemManagerCommon::DestroySystemService(const std::string &name, Service *caller)
     {
         cpp_freertos::LockGuard lck(serviceDestroyMutex);
         if (RequestServiceClose(name, caller)) {


@@ 366,7 366,7 @@ namespace sys
         return false;
     }
 
-    bool SystemManager::DestroyApplication(const std::string &name, Service *caller)
+    bool SystemManagerCommon::DestroyApplication(const std::string &name, Service *caller)
     {
         cpp_freertos::LockGuard lck(appDestroyMutex);
         if (RequestServiceClose(name, caller)) {


@@ 384,7 384,7 @@ namespace sys
         return false;
     }
 
-    void SystemManager::preCloseRoutine(CloseReason closeReason)
+    void SystemManagerCommon::preCloseRoutine(CloseReason closeReason)
     {
         for (const auto &service : servicesList) {
             auto msg = std::make_shared<ServiceCloseReasonMessage>(closeReason);


@@ 397,7 397,7 @@ namespace sys
         servicesPreShutdownRoutineTimeout.start();
     }
 
-    void SystemManager::postStartRoutine()
+    void SystemManagerCommon::postStartRoutine()
     {
         connect(sevm::BatteryStateChangeMessage(), [&](Message *) {
             switch (Store::Battery::get().levelState) {


@@ 418,7 418,7 @@ namespace sys
         });
     }
 
-    void SystemManager::batteryCriticalLevelAction(bool charging)
+    void SystemManagerCommon::batteryCriticalLevelAction(bool charging)
     {
         LOG_INFO("Battery Critical Level reached!");
         CellularServiceAPI::ChangeModulePowerState(this, cellular::service::State::PowerState::Off);


@@ 426,13 426,13 @@ namespace sys
         bus.sendUnicast(std::move(msg), service::name::appmgr);
     }
 
-    void SystemManager::batteryShutdownLevelAction()
+    void SystemManagerCommon::batteryShutdownLevelAction()
     {
         LOG_INFO("Battery level too low - shutting down the system...");
         CloseSystemHandler(CloseReason::LowBattery);
     }
 
-    void SystemManager::batteryNormalLevelAction()
+    void SystemManagerCommon::batteryNormalLevelAction()
     {
         LOG_INFO("Battery level normal.");
         CellularServiceAPI::ChangeModulePowerState(this, cellular::service::State::PowerState::On);


@@ 440,7 440,7 @@ namespace sys
         bus.sendUnicast(std::move(battNormalMsg), service::name::appmgr);
     }
 
-    void SystemManager::readyToCloseHandler(Message *msg)
+    void SystemManagerCommon::readyToCloseHandler(Message *msg)
     {
         if (!readyForCloseRegister.empty() && servicesPreShutdownRoutineTimeout.isActive()) {
             auto message = static_cast<ReadyToCloseMessage *>(msg);


@@ 458,7 458,7 @@ namespace sys
         }
     }
 
-    void SystemManager::kill(std::shared_ptr<Service> const &toKill)
+    void SystemManagerCommon::kill(std::shared_ptr<Service> const &toKill)
     {
         auto ret = toKill->DeinitHandler();
         if (ret != sys::ReturnCodes::Success) {


@@ 467,7 467,7 @@ namespace sys
         toKill->CloseHandler();
     }
 
-    ReturnCodes SystemManager::InitHandler()
+    ReturnCodes SystemManagerCommon::InitHandler()
     {
         isReady = true;
 


@@ 640,12 640,12 @@ namespace sys
         return ReturnCodes::Success;
     }
 
-    MessagePointer SystemManager::DataReceivedHandler(DataMessage * /*msg*/, ResponseMessage * /*resp*/)
+    MessagePointer SystemManagerCommon::DataReceivedHandler(DataMessage * /*msg*/, ResponseMessage * /*resp*/)
     {
         return std::make_shared<ResponseMessage>();
     }
 
-    void SystemManager::CloseSystemHandler(CloseReason closeReason)
+    void SystemManagerCommon::CloseSystemHandler(CloseReason closeReason)
     {
         LOG_DEBUG("Invoking closing procedure...");
 


@@ 660,7 660,7 @@ namespace sys
         preCloseRoutine(closeReason);
     }
 
-    void SystemManager::CloseServices()
+    void SystemManagerCommon::CloseServices()
     {
         for (const auto &element : readyForCloseRegister) {
             LOG_INFO("Service: %s did not reported before timeout", element.c_str());


@@ 673,7 673,7 @@ namespace sys
         set(State::Shutdown);
     }
 
-    void SystemManager::RestoreSystemHandler()
+    void SystemManagerCommon::RestoreSystemHandler()
     {
         LOG_INFO("Entering restore system state");
 


@@ 687,7 687,7 @@ namespace sys
         LOG_INFO("entered restore state");
     }
 
-    void SystemManager::UpdateSystemHandler()
+    void SystemManagerCommon::UpdateSystemHandler()
     {
         LOG_DEBUG("Starting system update procedure...");
 


@@ 699,7 699,7 @@ namespace sys
         DestroyServices(sys::state::update::whitelist);
     }
 
-    void SystemManager::RebootHandler(State state, std::optional<UpdateReason> updateReason)
+    void SystemManagerCommon::RebootHandler(State state, std::optional<UpdateReason> updateReason)
     {
         CloseSystemHandler(CloseReason::Reboot);
         set(state);


@@ 708,7 708,7 @@ namespace sys
         }
     }
 
-    void SystemManager::CpuStatisticsTimerHandler()
+    void SystemManagerCommon::CpuStatisticsTimerHandler()
     {
         if (!cpuStatisticsTimerInit) {
             cpuStatisticsTimerInit = true;


@@ 719,7 719,7 @@ namespace sys
         powerManager->UpdateCpuFrequency(cpuStatistics->GetPercentageCpuLoad());
     }
 
-    phone_modes::PhoneMode SystemManager::translateSliderState(const RawKey &key)
+    phone_modes::PhoneMode SystemManagerCommon::translateSliderState(const RawKey &key)
     {
         const auto code = key.keyCode;
         if (code != bsp::KeyCodes::SSwitchUp && code != bsp::KeyCodes::SSwitchMid &&


@@ 729,7 729,7 @@ namespace sys
         return SliderStateToPhoneModeMapping.at(code);
     }
 
-    MessagePointer SystemManager::handlePhoneModeRequest(PhoneModeRequest *request)
+    MessagePointer SystemManagerCommon::handlePhoneModeRequest(PhoneModeRequest *request)
     {
         LOG_INFO("Phone mode change requested.");
         if (phoneModeSubject->isTetheringEnabled()) {


@@ 742,7 742,7 @@ namespace sys
         return MessageNone{};
     }
 
-    MessagePointer SystemManager::handleTetheringStateRequest(TetheringStateRequest *request)
+    MessagePointer SystemManagerCommon::handleTetheringStateRequest(TetheringStateRequest *request)
     {
         LOG_INFO("Tethering state change requested");
 


@@ 768,13 768,13 @@ namespace sys
         return MessageNone{};
     }
 
-    MessagePointer SystemManager::enableTethering([[maybe_unused]] TetheringEnabledResponse *response)
+    MessagePointer SystemManagerCommon::enableTethering([[maybe_unused]] TetheringEnabledResponse *response)
     {
         phoneModeSubject->setTetheringMode(phone_modes::Tethering::On);
         return MessageNone{};
     }
 
-    void SystemManager::UpdateResourcesAfterCpuFrequencyChange(bsp::CpuFrequencyHz newFrequency)
+    void SystemManagerCommon::UpdateResourcesAfterCpuFrequencyChange(bsp::CpuFrequencyHz newFrequency)
     {
         if (newFrequency == bsp::CpuFrequencyHz::Level_1) {
             purefs::subsystem::disk_mgr()->pm_control(purefs::blkdev::pm_state::suspend);


@@ 784,12 784,12 @@ namespace sys
         }
     }
 
-    std::vector<std::shared_ptr<Service>> SystemManager::servicesList;
-    std::vector<std::shared_ptr<app::Application>> SystemManager::applicationsList;
-    cpp_freertos::MutexStandard SystemManager::serviceDestroyMutex;
-    cpp_freertos::MutexStandard SystemManager::appDestroyMutex;
-    std::unique_ptr<PowerManager> SystemManager::powerManager;
-    std::unique_ptr<CpuStatistics> SystemManager::cpuStatistics;
-    std::unique_ptr<DeviceManager> SystemManager::deviceManager;
+    std::vector<std::shared_ptr<Service>> SystemManagerCommon::servicesList;
+    std::vector<std::shared_ptr<app::Application>> SystemManagerCommon::applicationsList;
+    cpp_freertos::MutexStandard SystemManagerCommon::serviceDestroyMutex;
+    cpp_freertos::MutexStandard SystemManagerCommon::appDestroyMutex;
+    std::unique_ptr<PowerManager> SystemManagerCommon::powerManager;
+    std::unique_ptr<CpuStatistics> SystemManagerCommon::cpuStatistics;
+    std::unique_ptr<DeviceManager> SystemManagerCommon::deviceManager;
 
 } // namespace sys

@@ 75,7 75,7 @@ namespace sys
         UpdateReason updateReason;
     };
 
-    class SystemManager : public Service
+    class SystemManagerCommon : public Service
     {
       private:
         UpdateReason updateReason{UpdateReason::Update};


@@ 93,8 93,8 @@ namespace sys
             RebootToUpdate
         } state = State::Running;
 
-        explicit SystemManager(std::vector<std::unique_ptr<BaseServiceCreator>> &&creators);
-        ~SystemManager() override;
+        explicit SystemManagerCommon(std::vector<std::unique_ptr<BaseServiceCreator>> &&creators);
+        ~SystemManagerCommon() override;
 
         void set(enum State state);
 


@@ 230,20 230,20 @@ namespace sys
     };
 } // namespace sys
 
-inline const char *c_str(sys::SystemManager::State state)
+inline const char *c_str(sys::SystemManagerCommon::State state)
 {
     switch (state) {
-    case sys::SystemManager::State::Running:
+    case sys::SystemManagerCommon::State::Running:
         return "Running";
-    case sys::SystemManager::State::Suspend:
+    case sys::SystemManagerCommon::State::Suspend:
         return "Suspend";
-    case sys::SystemManager::State::Shutdown:
+    case sys::SystemManagerCommon::State::Shutdown:
         return "Shutdown";
-    case sys::SystemManager::State::Reboot:
+    case sys::SystemManagerCommon::State::Reboot:
         return "Reboot";
-    case sys::SystemManager::State::RebootToUpdate:
+    case sys::SystemManagerCommon::State::RebootToUpdate:
         return "RebootToUpdate";
-    case sys::SystemManager::State::ShutdownReady:
+    case sys::SystemManagerCommon::State::ShutdownReady:
         return "ShutdownReady";
     }
     return "";

@@ 28,7 28,7 @@
 #include <log/Logger.hpp>
 #include <log/log.hpp>
 #include <source/version.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <SystemWatchdog/SystemWatchdog.hpp>
 #include <thread.hpp>
 


@@ 71,7 71,7 @@ int main()
     systemServices.emplace_back(sys::CreatorFor<service::eink::ServiceEink>());
     systemServices.emplace_back(sys::CreatorFor<service::gui::ServiceGUI>());
 
-    auto sysmgr = std::make_shared<sys::SystemManager>(std::move(systemServices));
+    auto sysmgr = std::make_shared<sys::SystemManagerCommon>(std::move(systemServices));
     sysmgr->StartSystem(
         [&platform]() {
             try {

@@ 49,7 49,7 @@
 #include <log.hpp>
 #include <Logger.hpp>
 #include <source/version.hpp>
-#include <SystemManager/SystemManager.hpp>
+#include <SystemManager/SystemManagerCommon.hpp>
 #include <SystemWatchdog/SystemWatchdog.hpp>
 #include <thread.hpp>
 


@@ 100,7 100,7 @@ int main()
     systemServices.emplace_back(sys::CreatorFor<service::eink::ServiceEink>());
     systemServices.emplace_back(sys::CreatorFor<service::gui::ServiceGUI>());
 
-    auto sysmgr = std::make_shared<sys::SystemManager>(std::move(systemServices));
+    auto sysmgr = std::make_shared<sys::SystemManagerCommon>(std::move(systemServices));
     sysmgr->StartSystem(
         [&platform]() {
             try {

@@ 205,7 205,7 @@ void EventManager::handleKeyMoveEvent(RawKey key)
 {
     if (isSliderKeyCode(key.keyCode)) {
         LOG_INFO("Slider position: %s", magic_enum::enum_name(key.keyCode).data());
-        const auto mode = sys::SystemManager::translateSliderState(key);
+        const auto mode = sys::SystemManagerCommon::translateSliderState(key);
         bus.sendUnicast(std::make_shared<sys::PhoneModeRequest>(mode), service::name::system_manager);
     }
 }

@@ 10,7 10,7 @@
 
 #include <evtmgr/EventManager.hpp>
 #include <module-services/service-db/ServiceDB.hpp>
-#include <module-sys/SystemManager/SystemManager.hpp>
+#include <module-sys/SystemManager/SystemManagerCommon.hpp>
 
 #include <service-evtmgr/Constants.hpp>
 


@@ 23,7 23,8 @@ TEST_CASE("SettingsApi")
 {
     SECTION("variable/profile/mode register/set/get/unregister")
     {
-        auto manager = std::make_shared<sys::SystemManager>(std::vector<std::unique_ptr<sys::BaseServiceCreator>>{});
+        auto manager =
+            std::make_shared<sys::SystemManagerCommon>(std::vector<std::unique_ptr<sys::BaseServiceCreator>>{});
         std::shared_ptr<settings::MyService> varWritter;
         std::shared_ptr<settings::MyService> varReader;
         std::shared_ptr<settings::AppTest> testVar;


@@ 36,20 37,20 @@ TEST_CASE("SettingsApi")
             testStart = std::make_shared<std::mutex>();
             testStart->lock();
             std::cout << "start thr_id: " << std::this_thread::get_id() << std::endl << std::flush;
-            auto ret = sys::SystemManager::RunSystemService(std::make_shared<EventManager>(service::name::evt_manager),
-                                                            manager.get());
-            ret &= sys::SystemManager::RunSystemService(std::make_shared<ServiceDB>(), manager.get());
+            auto ret = sys::SystemManagerCommon::RunSystemService(
+                std::make_shared<EventManager>(service::name::evt_manager), manager.get());
+            ret &= sys::SystemManagerCommon::RunSystemService(std::make_shared<ServiceDB>(), manager.get());
 
             varWritter = std::make_shared<settings::MyService>("writterVar");
             varReader  = std::make_shared<settings::MyService>("readerVar");
 
             postMortemSetting = varWritter->getSettings();
 
-            ret &= sys::SystemManager::RunSystemService(varWritter, manager.get());
-            ret &= sys::SystemManager::RunSystemService(varReader, manager.get());
+            ret &= sys::SystemManagerCommon::RunSystemService(varWritter, manager.get());
+            ret &= sys::SystemManagerCommon::RunSystemService(varReader, manager.get());
 
             testVar = std::make_shared<settings::AppTest>("appTest", varWritter, varReader, testStart);
-            ret &= sys::SystemManager::RunSystemService(testVar, manager.get());
+            ret &= sys::SystemManagerCommon::RunSystemService(testVar, manager.get());
 
             std::cout << "koniec start thr_id: " << std::this_thread::get_id() << std::endl << std::flush;
             testStart->unlock();