Backup.

hal/include/IHalCpp.h

@@ -24,8 +24,17 @@ using VirtualKeyEvent = unsigned char;
 constexpr int INVALID_PERIOD = -1;
 constexpr int PERIPHERAL_CHECK_PERIOD_MS = 100;
 constexpr int IMEI_LEN = 15;
-constexpr long int KEY_DO_NOT_HOLD_PRESSING = -1;
+// constexpr long int KEY_DO_NOT_HOLD_PRESSING = -1;
 void CreateHalCppModule(void);
+class VKeyHalMonitor
+{
+public:
+    VKeyHalMonitor() = default;
+    virtual ~VKeyHalMonitor() = default;
+    virtual void KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs)
+    {
+    }
+};
 class VKeyHal
 {
 public:
@@ -34,6 +43,7 @@ public:
     virtual void CheckKeyStatus(void) {}
     virtual const std::string GetKeyName(void) { return "undefine"; }
     virtual void GetHoldPressingTimeMs(long int &holdTimeMs, VirtualKeyEvent &event) {}
+    virtual void SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor) {}
 };
 class VLedHal
 {

hal/src/HalCpp.cpp

@@ -24,8 +24,3 @@ StatusCode HalCpp::UnInit(void)
     LogInfo("HalCpp::UnInit\n");
     return CreateStatusCode(STATUS_CODE_OK);
 }
-StatusCode HalCpp::GetLedHals(std::vector<std::shared_ptr<VLedHal>> &ledHals)
-{
-    ledHals = mLedHals;
-    return CreateStatusCode(STATUS_CODE_OK);
-}

hal/src/HalCpp.h

@@ -22,7 +22,6 @@ public:
     virtual ~HalCpp() = default;
     StatusCode Init(void) override;
     StatusCode UnInit(void) override;
-    StatusCode GetLedHals(std::vector<std::shared_ptr<VLedHal>> &ledHals) override;
 
 private:
     std::vector<std::shared_ptr<VLedHal>> mLedHals;

middleware/DeviceManager/src/KeyManager.cpp

@@ -44,6 +44,7 @@ void KeyManager::StartTimer(void)
         LogError("StartTimer failed, no key to manager.\n");
         return;
     }
+    SetAllKeysMonitor();
     auto timerThread = [](std::shared_ptr<KeyManager> timer) {
         LogInfo("Key timer started.\n");
         timer->Timer();
@@ -62,11 +63,6 @@ void KeyManager::Timer(void)
     mTimerRuning = true;
     std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
     while (mTimerRuning) {
-        // for (int i = 0; i < static_cast<int>(SfKeyDefine::KEY_PIN_END); i++)
-        // {
-        //     mKeyManagers[static_cast<SfKeyDefine>(i)]->TimerKeyEventHappened(static_cast<SfKeyDefine>(i),
-        //     SfKeyEvent::KEY_EVENT_PRESSED, nullptr);
-        // }
         for (iter = mAllKeyHal.begin(); iter != mAllKeyHal.end(); ++iter) {
             std::shared_ptr<VKeyHal> keyHal = iter->second;
             keyHal->CheckKeyStatus();
@@ -85,4 +81,17 @@ void KeyManager::GetAllKeysState(std::map<std::string, KeyStatus> &status)
         KeyStatus result(holdPressingEvent, holdTimeMs);
         status.insert(std::make_pair(iter->first, result));
     }
+}
+void KeyManager::SetAllKeysMonitor(void)
+{
+    std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
+    for (iter = mAllKeyHal.begin(); iter != mAllKeyHal.end(); ++iter) {
+        std::shared_ptr<VKeyHal> keyHal = iter->second;
+        std::shared_ptr<VKeyHalMonitor> monitor = shared_from_this();
+        keyHal->SetKeyMonitor(monitor);
+    }
+}
+void KeyManager::KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs)
+{
+    //
 }

middleware/DeviceManager/src/KeyManager.h

@@ -20,7 +20,7 @@
 #include <memory>
 #include <mutex>
 #include <thread>
-class KeyManager : public std::enable_shared_from_this<KeyManager>
+class KeyManager : public VKeyHalMonitor, public std::enable_shared_from_this<KeyManager>
 {
 public:
     KeyManager() = default;
@@ -33,6 +33,13 @@ public:
     void Timer(void);
     void GetAllKeysState(std::map<std::string, KeyStatus> &status);
 
+private:
+    void SetAllKeysMonitor(void);
+
+private:
+    void KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event,
+                          const unsigned int &timeMs) override;
+
 private:
     std::mutex mMutex;
     std::map<std::string, std::shared_ptr<VKeyHal>> mAllKeyHal;

test/hal/tool/CMakeLists.txt

@@ -7,6 +7,7 @@ include_directories(
     ./include
     ${UTILS_SOURCE_PATH}/StatusCode/include
     ${UTILS_SOURCE_PATH}/Log/include
+    ${UTILS_SOURCE_PATH}/KeyControl/include
     # ${UTILS_SOURCE_PATH}/McuProtocol/include
     ${HAL_SOURCE_PATH}/src
     # /home/xiaojiazhu/project/rkipc/battery/ipc-rk1106/ipc-sdk/hal/src/HalCpp.h
@@ -20,7 +21,7 @@ include_directories(
 aux_source_directory(./src TEST_TOOL_SRC_FILES)
 set(TEST_TOOL_TARGET HalTestTool)
 add_library(${TEST_TOOL_TARGET} STATIC ${TEST_TOOL_SRC_FILES})
-target_link_libraries(${TEST_TOOL_TARGET} Log)
+target_link_libraries(${TEST_TOOL_TARGET} KeyControl Log)
 
 if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
 add_custom_target(

test/hal/tool/include/HalTestTool.h

@@ -15,6 +15,7 @@
 #ifndef HAL_TEST_TOOL_H
 #define HAL_TEST_TOOL_H
 #include "HalCpp.h"
+#include "KeyControl.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 using ::testing::_;
@@ -42,6 +43,7 @@ using ::testing::ReturnRefOfCopy;
 using ::testing::ReturnRoundRobin;
 using ::testing::SaveArg;
 using ::testing::SetArgPointee;
+using ::testing::SetArgReferee;
 using ::testing::SetArgumentPointee;
 using ::testing::Unused;
 using ::testing::WithArgs;
@@ -52,9 +54,11 @@ public:
     HalCppTest() = default;
     virtual ~HalCppTest() = default;
     StatusCode GetLedHals(std::vector<std::shared_ptr<VLedHal>> &ledHals) override;
+    StatusCode GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys) override;
 
 protected:
     virtual StatusCode GetLedHalsTrace(std::vector<std::shared_ptr<VLedHal>> &ledHals);
+    virtual StatusCode GetAllKeysTrace(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys);
 };
 class HalCppMock : public HalCppTest
 {
@@ -62,6 +66,27 @@ public:
     HalCppMock() = default;
     virtual ~HalCppMock() = default;
     MOCK_METHOD1(GetLedHalsTrace, StatusCode(std::vector<std::shared_ptr<VLedHal>> &));
+    MOCK_METHOD1(GetAllKeysTrace, StatusCode(std::map<std::string, std::shared_ptr<VKeyHal>> &));
+};
+class KeyControlTest : public KeyControl, public VKeyHal
+{
+public:
+    KeyControlTest() = default;
+    virtual ~KeyControlTest() = default;
+    unsigned int GetStatusCheckPeriodMs(void) override { return PERIPHERAL_CHECK_PERIOD_MS; }
+    void SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor) override;
+    void CheckKeyStatus(void) override;
+    void KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs) override;
+
+private:
+    std::shared_ptr<VKeyHalMonitor> mMonitor;
+};
+class KeyControlMock : public KeyControlTest
+{
+public:
+    KeyControlMock() = default;
+    virtual ~KeyControlMock() = default;
+    void SetKeyEvent(const KeyHalEvent &event);
 };
 class HalTestTool
 {
@@ -70,8 +95,16 @@ public:
     virtual ~HalTestTool() = default;
     void Init(void);
     void UnInit(void);
+    void SetAllKeysResult(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys);
+    void SetKeyEvent(const std::string keyName, const KeyHalEvent &event);
+
+private:
+    void HalMockInit(std::shared_ptr<HalCppMock> &mock);
+    void SetAllKeysResult(std::shared_ptr<HalCppMock> &mock, std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys);
+    std::shared_ptr<KeyControlMock> SearchKey(const std::string &keyName);
 
 private:
     std::shared_ptr<HalCppMock> mHalMock;
+    std::map<std::string, std::shared_ptr<VKeyHal>> mAllKeys;
 };
 #endif

test/hal/tool/src/HalTestTool.cpp

@@ -24,17 +24,49 @@ StatusCode HalCppTest::GetLedHals(std::vector<std::shared_ptr<VLedHal>> &ledHals
     }
     return code;
 }
+StatusCode HalCppTest::GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
+{
+    LogInfo("HalCppTest::GetAllKeys\n");
+    StatusCode code = GetAllKeysTrace(allKeys);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return HalCpp::GetAllKeys(allKeys);
+    }
+    return code;
+}
 StatusCode HalCppTest::GetLedHalsTrace(std::vector<std::shared_ptr<VLedHal>> &ledHals)
 {
-    //
     LogInfo("HalCppTest::GetLedHalsTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode HalCppTest::GetAllKeysTrace(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
+{
+    LogInfo("HalCppTest::GetAllKeysTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+void KeyControlTest::SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor)
+{
+    //
+    mMonitor = monitor;
+}
+void KeyControlTest::CheckKeyStatus(void)
+{
+    //
+    TimerKeyEventTrigger(KeyHalEvent::PRESSING);
+}
+void KeyControlTest::KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs)
+{
+    LogInfo("KeyEventTrigger time = %u\n", timeMs);
+    mMonitor->KeyEventHappened(keyName, static_cast<VirtualKeyEvent>(event), timeMs);
+}
+void KeyControlMock::SetKeyEvent(const KeyHalEvent &event)
+{
+    //
+    KeyHalEventTrigger(event);
+}
 void HalTestTool::Init(void)
 {
     mHalMock = std::make_shared<HalCppMock>();
-    EXPECT_CALL(*mHalMock.get(), GetLedHalsTrace(_))
+    HalMockInit(mHalMock);
-        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     OverrideHalMakePtrObject(mHalMock);
 }
 void HalTestTool::UnInit(void)
@@ -43,4 +75,44 @@ void HalTestTool::UnInit(void)
     // IHalCpp::GetInstance(&impl);
     mHalMock.reset();
     CancelOverrideHalMakePtrObject();
+}
+void HalTestTool::SetAllKeysResult(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
+{
+    SetAllKeysResult(mHalMock, allKeys);
+    mAllKeys = allKeys;
+}
+void HalTestTool::SetKeyEvent(const std::string keyName, const KeyHalEvent &event)
+{
+    std::shared_ptr<KeyControlMock> key = SearchKey(keyName);
+    if (!key) {
+        LogError("Can't set key event, key not found.\n");
+        return;
+    }
+    key->SetKeyEvent(event);
+}
+void HalTestTool::SetAllKeysResult(std::shared_ptr<HalCppMock> &mock,
+                                   std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
+{
+    EXPECT_CALL(*mock.get(), GetAllKeysTrace(_))
+        .WillRepeatedly(DoAll(SetArgReferee<0>(allKeys), Return(CreateStatusCode(STATUS_CODE_OK))));
+}
+std::shared_ptr<KeyControlMock> HalTestTool::SearchKey(const std::string &keyName)
+{
+    std::shared_ptr<KeyControlMock> mock;
+    std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
+    iter = mAllKeys.find(keyName);
+    if (iter != mAllKeys.end()) {
+        mock = std::dynamic_pointer_cast<KeyControlMock>(mAllKeys[keyName]);
+    }
+    else {
+        LogWarning("Can't found the key control.\n");
+    }
+    return mock;
+}
+void HalTestTool::HalMockInit(std::shared_ptr<HalCppMock> &mock)
+{
+    EXPECT_CALL(*mock.get(), GetLedHalsTrace(_))
+        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    EXPECT_CALL(*mock.get(), GetAllKeysTrace(_))
+        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
 }

test/middleware/DeviceManager/CMakeLists.txt

@@ -10,6 +10,7 @@ include_directories(
     ${UTILS_SOURCE_PATH}/StatusCode/include
     ${UTILS_SOURCE_PATH}/UartDevice/include
     ${UTILS_SOURCE_PATH}/McuProtocol/include
+    ${UTILS_SOURCE_PATH}/KeyControl/include
     ${HAL_SOURCE_PATH}/include
     ${HAL_SOURCE_PATH}/src
     ${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include

test/middleware/DeviceManager/src/DeviceManager_Test.cpp

@@ -59,8 +59,14 @@ public:
 // ../output_files/test/bin/DeviceManagerTest --gtest_filter=DeviceManagerTest.INTEGRATION_DeviceManager_EXAMPLE_Demo
 TEST_F(DeviceManagerTest, INTEGRATION_DeviceManager_EXAMPLE_Demo)
 {
+    std::map<std::string, std::shared_ptr<VKeyHal>> allKeys;
+    std::shared_ptr<KeyControlMock> key = std::make_shared<KeyControlMock>();
+    allKeys["test"] = key;
+    SetAllKeysResult(allKeys);
     IDeviceManager::GetInstance()->Init();
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    SetKeyEvent("test", KeyHalEvent::PRESSING);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     IDeviceManager::GetInstance()->UnInit();
 }
 } // namespace DeviceManagerTest

utils/KeyControl/include/KeyControl.h

@@ -18,7 +18,6 @@
 #include <memory>
 #include <mutex>
 constexpr long int KEY_DO_NOT_HOLD_PRESSING = -1;
-constexpr int PERIPHERAL_CHECK_PERIOD_MS = 100;
 constexpr int KEY_ACTION_LONG_CLICK = 1000 * 5;
 constexpr int KEY_ACTION_SHORT_CLICK = 200;
 constexpr int KEY_ACTION_HOLD_DWON = 500;
@@ -36,32 +35,27 @@ enum class KeyEvent
     HOLD_UP,
     END
 };
-class VKeyHal
-{
-public:
-    VKeyHal() = default;
-    virtual ~VKeyHal() = default;
-    virtual void KeyEventTrigger(const KeyHalEvent &event) {}
-    virtual void TimerKeyEventTrigger(const KeyHalEvent &event) {}
-    virtual long int GetHoldPressingTimeMs(void) { return KEY_DO_NOT_HOLD_PRESSING; }
-};
 class VKeyControl
 {
 public:
     VKeyControl() = default;
     virtual ~VKeyControl() = default;
-    // virtual void SetKeyHalOwner(std::shared_ptr<VKeyHal> owner) {}
     virtual const std::string GetKeyName(void) { return "undefine"; }
+    virtual unsigned int GetStatusCheckPeriodMs(void) { return 0; }
+    virtual void KeyHalEventTrigger(const KeyHalEvent &event) {}
+    virtual void KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs) {}
+    virtual void TimerKeyEventTrigger(const KeyHalEvent &event) {}
+    virtual long int GetHoldPressingTimeMs(void) { return KEY_DO_NOT_HOLD_PRESSING; }
 };
-using KeyActionReport = std::function<void(const std::string &, const KeyEvent &, const unsigned int &)>;
+// using KeyActionReport = std::function<void(const std::string &, const KeyEvent &, const unsigned int &)>;
-class KeyControl : public VKeyControl, public VKeyHal, public std::enable_shared_from_this<KeyControl>
+class KeyControl : public VKeyControl, public std::enable_shared_from_this<KeyControl>
 {
 public:
     KeyControl();
-    KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
+    // KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
-               const long int &longClickTime = KEY_ACTION_LONG_CLICK);
+    //            const long int &longClickTime = KEY_ACTION_LONG_CLICK);
     ~KeyControl();
-    void KeyEventTrigger(const KeyHalEvent &event) override;
+    void KeyHalEventTrigger(const KeyHalEvent &event) override;
     void TimerKeyEventTrigger(const KeyHalEvent &event) override;
     long int GetHoldPressingTimeMs(void) override;
     void Init(void);
@@ -75,8 +69,6 @@ private:
 
 private:
     std::mutex mMutex;
-    // std::shared_ptr<VKeyControl> mKeyHal;
-    KeyActionReport mKeyActionReport;
     long int mPressingTime;
     long int mLongClickTime;
 };

utils/KeyControl/src/KeyControl.cpp

@@ -19,18 +19,18 @@ constexpr unsigned int NOT_A_HOLD_KEY_ACTION = 0;
 KeyControl::KeyControl()
 {
     // mKeyHal = nullptr;
-    mKeyActionReport = nullptr;
+    // mKeyActionReport = nullptr;
     mPressingTime = KEY_NOT_PRESSING;
     mLongClickTime = 0;
 }
-KeyControl::KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
+// KeyControl::KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
-                       const long int &longClickTime)
+//                        const long int &longClickTime)
-    : mKeyActionReport(keyAction), mLongClickTime(longClickTime)
+//     : mKeyActionReport(keyAction), mLongClickTime(longClickTime)
-{
+// {
-    mPressingTime = KEY_NOT_PRESSING;
+//     mPressingTime = KEY_NOT_PRESSING;
-}
+// }
 KeyControl::~KeyControl() {}
-void KeyControl::KeyEventTrigger(const KeyHalEvent &event)
+void KeyControl::KeyHalEventTrigger(const KeyHalEvent &event)
 {
     std::lock_guard<std::mutex> locker(mMutex);
     ActionReport(GetKeyName(), event);
@@ -49,7 +49,7 @@ void KeyControl::UnInit(void) {}
 void KeyControl::ActionReport(const std::string &key, const KeyHalEvent &keyEvent)
 {
     if (KEY_PRESSING <= mPressingTime) {
-        mPressingTime += PERIPHERAL_CHECK_PERIOD_MS;
+        mPressingTime += GetStatusCheckPeriodMs();
     }
     switch (keyEvent) {
     case KeyHalEvent::PRESSING:
@@ -67,14 +67,9 @@ void KeyControl::KeyPressingTrigger(const std::string &key)
 {
     if (mLongClickTime <= mPressingTime) // Do not support long click, it should be count in application code.
     {
-        if (mKeyActionReport) {
-            // mKeyActionReport(key, KeyEvent::SF_KEY_ACTION_LONG_CLICK, NOT_A_HOLD_KEY_ACTION);
-        }
     }
     if (mPressingTime != KEY_NOT_PRESSING && mPressingTime % KEY_ACTION_HOLD_DWON == 0) {
-        if (mKeyActionReport) {
+        KeyEventTrigger(key, KeyEvent::HOLD_DOWN, mPressingTime);
-            mKeyActionReport(key, KeyEvent::HOLD_DOWN, mPressingTime);
-        }
     }
     if (KEY_NOT_PRESSING == mPressingTime) {
         mPressingTime = KEY_PRESSING;
@@ -83,14 +78,10 @@ void KeyControl::KeyPressingTrigger(const std::string &key)
 void KeyControl::KeyNotPressingTrigger(const std::string &key)
 {
     if (KEY_ACTION_SHORT_CLICK <= mPressingTime && mPressingTime < KEY_ACTION_HOLD_DWON) {
-        if (mKeyActionReport) {
+        KeyEventTrigger(key, KeyEvent::SHORT_CLICK, mPressingTime);
-            mKeyActionReport(key, KeyEvent::SHORT_CLICK, NOT_A_HOLD_KEY_ACTION);
-        }
     }
     if (KEY_ACTION_HOLD_DWON <= mPressingTime) {
-        if (mKeyActionReport) {
+        KeyEventTrigger(key, KeyEvent::HOLD_UP, mPressingTime);
-            mKeyActionReport(key, KeyEvent::HOLD_UP, mPressingTime);
-        }
     }
     mPressingTime = KEY_NOT_PRESSING;
 }