Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Backup.

Browse Source
This commit is contained in:
Fancy code 2024-02-16 10:48:14 -08:00
parent dcdf20106e
commit 1ada288d3f
12 changed files with 172 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
hal/include/IHalCpp.h
View File

@ -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
{

5
hal/src/HalCpp.cpp
View File

@ -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);
}

1
hal/src/HalCpp.h
View File

@ -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;

19
middleware/DeviceManager/src/KeyManager.cpp
View File

@ -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)
{
//
}

9
middleware/DeviceManager/src/KeyManager.h
View File

@ -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;

3
test/hal/tool/CMakeLists.txt
View File

@ -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(

33
test/hal/tool/include/HalTestTool.h
View File

@ -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

78
test/hal/tool/src/HalTestTool.cpp
View File

@ -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(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
HalMockInit(mHalMock);
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))));
}

1
test/middleware/DeviceManager/CMakeLists.txt
View File

@ -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

6
test/middleware/DeviceManager/src/DeviceManager_Test.cpp
View File

@ -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

28
utils/KeyControl/include/KeyControl.h
View File

@ -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 &)>;
class KeyControl : public VKeyControl, public VKeyHal, public std::enable_shared_from_this<KeyControl>
// using KeyActionReport = std::function<void(const std::string &, const KeyEvent &, const unsigned int &)>;
class KeyControl : public VKeyControl, public std::enable_shared_from_this<KeyControl>
{
public:
KeyControl();
KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
const long int &longClickTime = KEY_ACTION_LONG_CLICK);
// KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
// 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;
};

33
utils/KeyControl/src/KeyControl.cpp
View File

@ -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,
const long int &longClickTime)
: mKeyActionReport(keyAction), mLongClickTime(longClickTime)
{
mPressingTime = KEY_NOT_PRESSING;
}
// KeyControl::KeyControl(std::shared_ptr<VKeyControl> &keyHal, const KeyActionReport &keyAction,
// const long int &longClickTime)
// : mKeyActionReport(keyAction), mLongClickTime(longClickTime)
// {
// 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) {
mKeyActionReport(key, KeyEvent::HOLD_DOWN, mPressingTime);
}
KeyEventTrigger(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) {
mKeyActionReport(key, KeyEvent::SHORT_CLICK, NOT_A_HOLD_KEY_ACTION);
}
KeyEventTrigger(key, KeyEvent::SHORT_CLICK, mPressingTime);
}
if (KEY_ACTION_HOLD_DWON <= mPressingTime) {
if (mKeyActionReport) {
mKeyActionReport(key, KeyEvent::HOLD_UP, mPressingTime);
}
KeyEventTrigger(key, KeyEvent::HOLD_UP, mPressingTime);
}
mPressingTime = KEY_NOT_PRESSING;
}