8 files changed, 79 insertions(+), 35 deletions(-)

M module-bsp/board/rt1051/bsp/eink/EinkDisplay.cpp
M module-sys/SystemManager/SystemManagerCommon.cpp
M module-sys/SystemManager/include/SystemManager/SystemManagerCommon.hpp
M products/BellHybrid/sys/SystemManager.cpp
M products/BellHybrid/sys/include/sys/SystemManager.hpp
M products/PurePhone/sys/CMakeLists.txt
M products/PurePhone/sys/SystemManager.cpp
M products/PurePhone/sys/include/sys/SystemManager.hpp

@@ 407,6 407,14 @@ namespace hal::eink
         }
         while (status != EinkStatus::EinkOK && errorCounter++ < EinkDisplayMaxInitRetries) {
             status = tryReinitAndPowerOn();
+            if (status != EinkStatus::EinkOK) {
+                if (errorCounter < EinkDisplayMaxInitRetries) {
+                    LOG_WARN("Failed to initialize and power on Eink, trying once more...");
+                }
+                else {
+                    LOG_ERROR("Permanently failed to initialize and power on Eink");
+                }
+            }
         }
 
         return status;


@@ 415,9 423,11 @@ namespace hal::eink
     EinkStatus EinkDisplay::tryReinitAndPowerOn()
     {
         if (const auto status = resetAndInit(); status != EinkStatus::EinkOK) {
+            LOG_WARN("Eink initialization failed (%s)", magic_enum::enum_name(status).data());
             return status;
         }
         if (const auto status = powerOn(); status != EinkStatus::EinkOK) {
+            LOG_WARN("Eink power on failed (%s)", magic_enum::enum_name(status).data());
             return status;
         }
         return EinkStatus::EinkOK;

@@ 18,7 18,6 @@
 #include <service-evtmgr/EVMessages.hpp>
 #include <service-appmgr/messages/OnboardingPowerDownRequest.hpp>
 #include <service-appmgr/messages/UserPowerDownRequest.hpp>
-#include <service-desktop/ServiceDesktopName.hpp>
 #include <service-appmgr/ServiceApplicationManagerName.hpp>
 #include <service-appmgr/Controller.hpp>
 #include <system/messages/DeviceRegistrationMessage.hpp>


@@ 29,10 28,8 @@
 #include "Timers/TimerFactory.hpp"
 #include <service-appmgr/StartupType.hpp>
 #include <purefs/vfs_subsystem.hpp>
-#include <service-gui/ServiceGUIName.hpp>
-#include <service-db/DBServiceName.hpp>
+
 #include <module-gui/gui/Common.hpp>
-#include <service-eink/ServiceEinkName.hpp>
 #include <hal/boot_control.h>
 #include <algorithm>
 


@@ 64,35 61,13 @@ namespace sys
         }
 
     } // namespace
-
     namespace state
     {
-        namespace restore
-        {
-            static constexpr std::array whitelist = {
-                service::name::service_desktop, // Handle restore procedure
-                service::name::evt_manager, // Workaround for charging battery after shutting down and turn on the phone
-                service::name::appmgr,
-                service::name::cellular,
-            };
-        }
-
-        namespace regularClose
-        {
-            static constexpr std::array whitelist = {service::name::evt_manager, service::name::cellular};
-        }
-
-        namespace update
-        {
-            static constexpr std::array whitelist = {service::name::evt_manager, service::name::cellular};
-        }
-
         template <typename T>
         static bool isOnWhitelist(const T &list, const std::string &serviceName)
         {
             return std::find(std::begin(list), std::end(list), serviceName) != std::end(list);
         }
-
     } // namespace state
 
     using namespace cpp_freertos;


@@ 177,7 152,6 @@ namespace sys
             handleShutdown();
         }
 
-        DestroySystemService(service::name::evt_manager, this);
         CloseService();
 
         // it should be called before systemDeinit to make sure this log is dumped to the file


@@ 725,16 699,16 @@ namespace sys
         case CloseReason::OnboardingPowerDown:
         case CloseReason::SystemBrownout:
         case CloseReason::LowBattery:
-            DestroyServices(sys::state::regularClose::whitelist);
+            DestroyServices(getWhiteListFor(WhiteListType::RegularClose));
             set(State::Shutdown);
             break;
         case CloseReason::Reboot:
-            DestroyServices(sys::state::regularClose::whitelist);
+            DestroyServices(getWhiteListFor(WhiteListType::RegularClose));
             set(State::Reboot);
             break;
         case CloseReason::RebootToRecovery:
         case CloseReason::FactoryReset:
-            DestroyServices(sys::state::update::whitelist);
+            DestroyServices(getWhiteListFor(WhiteListType::Update));
             set(State::RebootToRecovery);
             break;
         }


@@ 751,7 725,7 @@ namespace sys
         }
         CriticalSection::Exit();
 
-        DestroyServices(sys::state::restore::whitelist);
+        DestroyServices(getWhiteListFor(WhiteListType::Restore));
 
         LOG_INFO("entered restore state");
     }

@@ 20,6 20,7 @@
 #include "DeviceManager.hpp"
 #include <chrono>
 #include <vector>
+#include <algorithm>
 
 namespace app
 {


@@ 46,6 47,12 @@ namespace sys
         FactoryReset,
         None,
     };
+    enum class WhiteListType
+    {
+        RegularClose,
+        Update,
+        Restore
+    };
 
     class SystemInitialisationError : public std::runtime_error
     {


@@ 134,7 141,8 @@ namespace sys
         virtual void batteryNormalLevelAction();
         virtual void batteryCriticalLevelAction(bool charging);
         virtual void batteryShutdownLevelAction();
-        virtual void handleShutdown() = 0;
+        virtual void handleShutdown()                                               = 0;
+        virtual const std::vector<std::string> &getWhiteListFor(WhiteListType type) = 0;
 
       private:
         MessagePointer DataReceivedHandler(DataMessage *msg, ResponseMessage *resp) override;

@@ 11,6 11,14 @@
 
 namespace sys
 {
+    namespace
+    {
+        namespace RegularClose
+        {
+            const std::vector<std::string> whitelist{};
+        } // namespace RegularClose
+    }     // namespace
+
     SystemManager::SystemManager(std::vector<std::unique_ptr<BaseServiceCreator>> &&creators)
         : SystemManagerCommon(std::move(creators))
     {}


@@ 45,4 53,9 @@ namespace sys
     {
         set(State::ShutdownReady);
     }
+
+    const std::vector<std::string> &SystemManager::getWhiteListFor(WhiteListType /*type*/)
+    {
+        return RegularClose::whitelist;
+    }
 } // namespace sys

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once


@@ 20,5 20,7 @@ namespace sys
         auto handleAlarmActivationStatusChangeRequest(AlarmActivationStatusChangeRequest *request) -> MessagePointer;
 
         void handleShutdown() override;
+
+        const std::vector<std::string> &getWhiteListFor(WhiteListType type) override;
     };
 } // namespace sys

@@ 21,4 21,5 @@ target_link_libraries(sys
         module-utils
         module-sys
         service-appmgr
+        service-desktop
 )

@@ 13,6 13,7 @@
 #include <service-cellular/CellularServiceAPI.hpp>
 #include <service-evtmgr/ServiceEventManagerName.hpp>
 #include <service-evtmgr/EventManagerServiceAPI.hpp>
+#include <service-desktop/ServiceDesktopName.hpp>
 
 namespace sys
 {


@@ 22,7 23,24 @@ namespace sys
             {bsp::KeyCodes::SSwitchUp, phone_modes::PhoneMode::Connected},
             {bsp::KeyCodes::SSwitchMid, phone_modes::PhoneMode::DoNotDisturb},
             {bsp::KeyCodes::SSwitchDown, phone_modes::PhoneMode::Offline}};
-    } // namespace
+
+        namespace RegularClose
+        {
+            const std::vector<std::string> whitelist{service::name::evt_manager, service::name::cellular};
+        } // namespace RegularClose
+        namespace Update
+        {
+            const std::vector<std::string> whitelist{service::name::evt_manager, service::name::cellular};
+        } // namespace Update
+        namespace Restore
+        {
+            const std::vector<std::string> whitelist{
+                service::name::service_desktop, // Handle restore procedure
+                service::name::evt_manager, // Workaround for charging battery after shutting down and turn on the phone
+                service::name::appmgr,
+                service::name::cellular};
+        } // namespace Restore
+    }     // namespace
 
     SystemManager::SystemManager(std::vector<std::unique_ptr<BaseServiceCreator>> &&creators)
         : SystemManagerCommon(std::move(creators))


@@ 165,6 183,7 @@ namespace sys
         // check if we are discharging - if so -> shutdown
         if (Store::Battery::get().state == Store::Battery::State::Discharging) {
             set(State::ShutdownReady);
+            DestroySystemService(service::name::evt_manager, this);
         }
         else {
             // await from EvtManager for info that red key was pressed / timeout


@@ 179,4 198,20 @@ namespace sys
             msg->Execute(this);
         }
     }
+
+    const std::vector<std::string> &SystemManager::getWhiteListFor(WhiteListType type)
+    {
+        switch (type) {
+        case WhiteListType::RegularClose: {
+            return RegularClose::whitelist;
+        }
+        case WhiteListType::Update: {
+            return Update::whitelist;
+        }
+        case WhiteListType::Restore: {
+            return Restore::whitelist;
+        }
+        }
+        return RegularClose::whitelist;
+    }
 } // namespace sys

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once


@@ 33,6 33,7 @@ namespace sys
         void batteryNormalLevelAction() override;
         void batteryCriticalLevelAction(bool charging) override;
         void handleShutdown() override;
+        const std::vector<std::string> &getWhiteListFor(WhiteListType type) override;
 
         std::unique_ptr<phone_modes::Subject> phoneModeSubject;
     };