10 files changed, 80 insertions(+), 67 deletions(-)

M module-bsp/board/linux/battery-charger/battery_charger.cpp
M module-bsp/board/rt1051/bsp/battery-charger/battery_charger.cpp
M module-bsp/bsp/battery-charger/battery_charger.hpp
M module-services/service-evtmgr/CMakeLists.txt
M module-services/service-evtmgr/EventManager.cpp
M module-services/service-evtmgr/WorkerEvent.cpp
A module-services/service-evtmgr/battery-level-check/BatteryLevelCheck.cpp
A module-services/service-evtmgr/battery-level-check/BatteryLevelCheck.hpp
M module-services/service-evtmgr/service-evtmgr/BatteryMessages.hpp
M module-services/service-evtmgr/service-evtmgr/WorkerEvent.hpp

@@ 34,11 34,6 @@ static uint8_t battLevel = 100;
 static bool plugged      = false;
 namespace bsp
 {
-    namespace
-    {
-        std::uint8_t batteryCriticalLevel = 5;
-    } // namespace
-
     static void battery_worker(void *pvp);
 
     int battery_Init(xQueueHandle qHandle)


@@ 49,8 44,6 @@ namespace bsp
         }
         Store::Battery::modify().level = battLevel;
 
-        uint8_t notification = static_cast<uint8_t>(bsp::batteryIRQSource::checkCriticalLevel);
-        xQueueSend(qHandleIrq, &notification, 100);
         return 0;
     }
 


@@ 112,22 105,11 @@ namespace bsp
                     if (battLevel >= 1)
                         battLevel--;
                     break;
+                }
                 xQueueSend(qHandleIrq, &notification, 100);
             }
             vTaskDelay(50);
         }
     }
 
-    void battery_setCriticalLevel(std::uint8_t level)
-    {
-        batteryCriticalLevel = level;
-        uint8_t notification = static_cast<uint8_t>(bsp::batteryIRQSource::checkCriticalLevel);
-        xQueueSend(qHandleIrq, &notification, 100);
-    }
-
-    bool battery_isLevelCritical(std::uint8_t level)
-    {
-        return level <= batteryCriticalLevel;
-    }
-
 } // namespace bsp

@@ 100,20 100,6 @@ static xQueueHandle qHandleIrq = NULL;
 
 namespace bsp
 {
-    namespace
-    {
-        std::uint8_t batteryLevelCritical = 5;
-
-        void triggerCriticalLevelCheck()
-        {
-            if (qHandleIrq != NULL) {
-                BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-                uint8_t val                         = static_cast<uint8_t>(bsp::batteryIRQSource::checkCriticalLevel);
-                xQueueSendFromISR(qHandleIrq, &val, &xHigherPriorityTaskWoken);
-            }
-        }
-    } // namespace
-
     // STATUS register bits
     enum B_STATUS
     {


@@ 188,8 174,6 @@ namespace bsp
 
         s_BSP_BatteryChargerIrqPinsInit();
 
-        triggerCriticalLevelCheck();
-
         return 0;
     }
 


@@ 207,17 191,6 @@ namespace bsp
         gpio.reset();
     }
 
-    void battery_setCriticalLevel(std::uint8_t level)
-    {
-        batteryLevelCritical = level;
-        triggerCriticalLevelCheck();
-    }
-
-    bool battery_isLevelCritical(std::uint8_t level)
-    {
-        return level <= batteryLevelCritical;
-    }
-
     void battery_getBatteryLevel(uint8_t &levelPercent)
     {
         uint16_t val = 0;

@@ 99,8 99,7 @@ namespace bsp{
 
 	enum class batteryIRQSource{
 		INTB = 0x01,
-		INOKB = 0x02,
-		checkCriticalLevel
+		INOKB = 0x02
 	};
 
 	int battery_Init(xQueueHandle qHandle);


@@ 114,10 113,6 @@ namespace bsp{
 	void battery_ClearAllIRQs(void);
 
 	void battery_clearFuelGuageIRQ(void);
-
-	void battery_setCriticalLevel(std::uint8_t level);
-
-	bool battery_isLevelCritical(std::uint8_t level);
 }
 
 BaseType_t BSP_BatteryChargerINOKB_IRQHandler();

@@ 9,6 9,7 @@ set(SOURCES
         messages/Message.cpp
         screen-light-control/ScreenLightControl.cpp
         screen-light-control/ControlFunctions.cpp
+        battery-level-check/BatteryLevelCheck.cpp
 )
 
 add_library(${PROJECT_NAME} STATIC ${SOURCES})

@@ 8,6 8,7 @@
 #include "service-evtmgr/KbdMessage.hpp"
 #include "service-evtmgr/WorkerEvent.hpp"
 #include "screen-light-control/ScreenLightControl.hpp"
+#include "battery-level-check/BatteryLevelCheck.hpp"
 
 #include <BaseInterface.hpp>
 #include <MessageType.hpp>


@@ 288,7 289,7 @@ sys::ReturnCodes EventManager::InitHandler()
 
     connect(sevm::BatterySetCriticalLevel(0), [&](sys::Message *msgl) {
         auto request = static_cast<sevm::BatterySetCriticalLevel *>(msgl);
-        bsp::battery_setCriticalLevel(request->criticalLevel);
+        battery_level_check::setBatteryCriticalLevel(request->criticalLevel);
         return std::make_shared<sys::ResponseMessage>();
     });
 

@@ 6,6 6,7 @@
 #include "service-evtmgr/EVMessages.hpp"
 #include "service-evtmgr/KbdMessage.hpp"
 #include "service-evtmgr/WorkerEvent.hpp"
+#include "battery-level-check/BatteryLevelCheck.hpp"
 
 #include <Audio/AudioCommon.hpp>
 #include <MessageType.hpp>


@@ 44,6 45,11 @@ extern "C"
 #include <string>      // for string
 #include <vector>      // for vector
 
+WorkerEvent::WorkerEvent(sys::Service *service) : sys::Worker(service), service(service)
+{
+    battery_level_check::init(service);
+}
+
 bool WorkerEvent::handleMessage(uint32_t queueID)
 {
 


@@ 98,10 104,7 @@ bool WorkerEvent::handleMessage(uint32_t queueID)
             message->levelPercents = battLevel;
             message->fullyCharged  = false;
             sys::Bus::SendUnicast(message, service::name::evt_manager, this->service);
-            if (bsp::battery_isLevelCritical(battLevel)) {
-                auto levelCriticalMessage = std::make_shared<sevm::BatteryLevelCriticalMessage>();
-                sys::Bus::SendUnicast(levelCriticalMessage, service::name::system_manager, this->service);
-            }
+            battery_level_check::checkBatteryLevelCritical();
         }
         if (notification == static_cast<uint8_t>(bsp::batteryIRQSource::INOKB)) {
             bool status;


@@ 111,14 114,6 @@ bool WorkerEvent::handleMessage(uint32_t queueID)
             message->plugged = status;
             sys::Bus::SendUnicast(message, service::name::evt_manager, this->service);
         }
-        if (notification == static_cast<uint8_t>(bsp::batteryIRQSource::checkCriticalLevel)) {
-            if (Store::Battery::get().state == Store::Battery::State::Discharging) {
-                if (bsp::battery_isLevelCritical(Store::Battery::get().level)) {
-                    auto levelCriticalMessage = std::make_shared<sevm::BatteryLevelCriticalMessage>();
-                    sys::Bus::SendUnicast(levelCriticalMessage, service::name::system_manager, this->service);
-                }
-            }
-        }
     }
 
     if (queueID == static_cast<uint32_t>(WorkerEventQueues::queueRTC)) {

@@ 0,0 1,46 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "BatteryLevelCheck.hpp"
+#include "service-evtmgr/BatteryMessages.hpp"
+#include "SystemManager/Constants.hpp"
+
+#include <Service/Bus.hpp>
+#include <common_data/EventStore.hpp>
+
+namespace battery_level_check
+{
+    namespace
+    {
+        unsigned int batteryLevelCritical = 10;
+
+        sys::Service *parentService = nullptr;
+
+        bool isBatteryLevelCritical(unsigned int level)
+        {
+            return level < batteryLevelCritical;
+        }
+    } // namespace
+
+    void init(sys::Service *service)
+    {
+        parentService = service;
+    }
+
+    void checkBatteryLevelCritical()
+    {
+        if (Store::Battery::get().state == Store::Battery::State::Discharging) {
+            if (isBatteryLevelCritical(Store::Battery::get().level)) {
+                auto levelCriticalMessage = std::make_shared<sevm::BatteryLevelCriticalMessage>();
+                sys::Bus::SendUnicast(levelCriticalMessage, service::name::system_manager, parentService);
+            }
+        }
+    }
+
+    void setBatteryCriticalLevel(unsigned int level)
+    {
+        batteryLevelCritical = level;
+        checkBatteryLevelCritical();
+    }
+
+} // namespace battery_level_check

@@ 0,0 1,20 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <Service/Service.hpp>
+
+namespace sys
+{
+    class Service;
+} // namespace sys
+
+namespace battery_level_check
+{
+    void init(sys::Service *service);
+
+    void checkBatteryLevelCritical();
+
+    void setBatteryCriticalLevel(unsigned int level);
+} // namespace battery_level_check

@@ 35,7 35,7 @@ namespace sevm
         BatterySetCriticalLevel(std::uint8_t level)
             : Message(MessageType::EVMBatterySetCriticalLevel), criticalLevel(level)
         {}
-        std::uint8_t criticalLevel = 0;
+        unsigned int criticalLevel = 0;
     };
 
     class BatteryLevelCriticalMessage : public Message

@@ 61,7 61,7 @@ class WorkerEvent : public sys::Worker
     sys::Service *service     = nullptr;
 
   public:
-    WorkerEvent(sys::Service *service) : sys::Worker(service), service(service){};
+    WorkerEvent(sys::Service *service);
     /**
      * This function is responsible for creating all queues provided in the constructor.
      * When all queues are created this method creates set of queues.