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-05-17 14:26:28 +08:00
parent 16b86dbe0e
commit 95aa8c86c9
7 changed files with 508 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
middleware/IpcConfig/README.md Normal file
View File

@ -0,0 +1,15 @@
# 1. IPC配置文件库
## 1.1. 概述
  配置文件库，用于读写IPC的配置文件。适用于打猎机产品。
## 1.2. 软件设计
1. 使用了第三方开源库libconfig；
2. 本库使用结构体保存数据，可拓展不使用第三方开源库，直接保存结构体数据即可；在资源受限时，可动/静态取消第三方开源库；
3. 配置文件明文显示，可加密；
## 1.3. 数据丢失还原机制
## 1.4. 数据备份还原机制

12
middleware/IpcConfig/include/IIpcConfig.h
View File

@ -43,11 +43,11 @@ enum class IpcConfigKey
TEST_FLOAT, TEST_FLOAT,
END END
}; };
enum WorkMode enum class WorkMode
{ {
WORK_MODE_PIC = 0, MODE_PIC = 0,
WORK_MODE_PIC_VIDEO, MODE_PIC_VIDEO,
WORK_MODE_END, END,
}; };
enum ContinuousShot enum ContinuousShot
{ {
@ -120,6 +120,8 @@ public:
virtual const bool GetBool(const IpcConfigKey &key); virtual const bool GetBool(const IpcConfigKey &key);
virtual void SetBool(const IpcConfigKey &key, const bool &value); virtual void SetBool(const IpcConfigKey &key, const bool &value);
virtual const std::string GetString(const IpcConfigKey &key); virtual const std::string GetString(const IpcConfigKey &key);
virtual void SetString(const IpcConfigKey &key, const std::string string); virtual void SetString(const IpcConfigKey &key, const std::string &string);
virtual WorkMode GetWorkMode(void);
virtual void SetWorkMode(const WorkMode &mode);
}; };
#endif #endif

9
middleware/IpcConfig/src/IIpcConfig.cpp
View File

@ -107,6 +107,13 @@ const std::string IIpcConfig::GetString(const IpcConfigKey &key)
{ {
return "undefine"; return "undefine";
} }
void IIpcConfig::SetString(const IpcConfigKey &key, const std::string string) void IIpcConfig::SetString(const IpcConfigKey &key, const std::string &string)
{
}
WorkMode IIpcConfig::GetWorkMode(void)
{
return WorkMode::END;
}
void IIpcConfig::SetWorkMode(const WorkMode &mode)
{ {
} }

641
middleware/IpcConfig/src/IpcConfigImpl.cpp
View File

@ -17,89 +17,119 @@
#include <string.h> #include <string.h>
#define CHECK_MAP(map) (map.size() == 1 ? true : false) #define CHECK_MAP(map) (map.size() == 1 ? true : false)
const char *CONFIG_WIFI_SSID = "wifi_ssid";
const char *CONFIG_WIFI_SSID_DEFAULT = "Hunting 2024";
const char *CONFIG_WIFI_PASSWORD = "wifi_password";
const char *CONFIG_WIFI_PASSWORD_DEFAULT = "123456";
const char *CONFIG_WORK_MODE = "work_mode";
const char *CONFIG_CONTINUE_SHOT = "continuous_shot";
IpcConfigImpl::IpcConfigImpl() IpcConfigImpl::IpcConfigImpl()
{ {
mCfgChanged = CONFIG_HAS_NOT_CHANGED; mCfgChanged = CONFIG_HAS_NOT_CHANGED;
std::map<std::string, std::reference_wrapper<int>> innerMapWorkMode; memset(&mAllData, 0, sizeof(Config_s));
innerMapWorkMode.insert(std::make_pair("work_mode", std::reference_wrapper<int>(mAllData.workMode))); {
mCfgMapInt.insert(std::make_pair(IpcConfigKey::WORK_MODE, innerMapWorkMode)); std::map<std::string, StringConfigPack> config;
StringConfigPack pack = {WIFI_SSID_BUFF_SIZE, mAllData.mWifiSsid};
config.insert(std::make_pair(CONFIG_WIFI_SSID, pack));
mCfgMapStringV2.insert(std::make_pair(IpcConfigKey::WIFI_SSID, config));
}
{
std::map<std::string, StringConfigPack> config;
StringConfigPack pack = {WIFI_PASSWORD_BUFF_SIZE, mAllData.mWifiPassword};
config.insert(std::make_pair(CONFIG_WIFI_PASSWORD, pack));
mCfgMapStringV2.insert(std::make_pair(IpcConfigKey::WIFI_PASSWORD, config));
}
{
std::map<std::string, char *> config;
config.insert(std::make_pair(CONFIG_WORK_MODE, &mAllData.mWorkMode));
mCfgMapCharV2.insert(std::make_pair(IpcConfigKey::WORK_MODE, config));
}
{
std::map<std::string, int *> config;
config.insert(std::make_pair(CONFIG_CONTINUE_SHOT, &mAllData.mContinuousShot));
mCfgMapIntV2.insert(std::make_pair(IpcConfigKey::CONTINUOUS_SHOT, config));
}
std::map<std::string, std::reference_wrapper<int>> innerMapContinuousShot; // std::map<std::string, std::reference_wrapper<int>> innerMapWorkMode;
innerMapContinuousShot.insert( // innerMapWorkMode.insert(std::make_pair("work_mode", std::reference_wrapper<int>(mAllData.mWorkMode)));
std::make_pair("continuous_shot", std::reference_wrapper<int>(mAllData.continuousShot))); // mCfgMapInt.insert(std::make_pair(IpcConfigKey::WORK_MODE, innerMapWorkMode));
mCfgMapInt.insert(std::make_pair(IpcConfigKey::CONTINUOUS_SHOT, innerMapContinuousShot));
std::map<std::string, std::reference_wrapper<int>> innerMapBurstPhotoInterval; // std::map<std::string, std::reference_wrapper<int>> innerMapContinuousShot;
innerMapBurstPhotoInterval.insert( // innerMapContinuousShot.insert(
std::make_pair("burst_photo_interval", std::reference_wrapper<int>(mAllData.burstPhotoInterval))); // std::make_pair("continuous_shot", std::reference_wrapper<int>(mAllData.mContinuousShot)));
mCfgMapInt.insert(std::make_pair(IpcConfigKey::BURST_PHOTO_INTERVAL, innerMapBurstPhotoInterval)); // mCfgMapInt.insert(std::make_pair(IpcConfigKey::CONTINUOUS_SHOT, innerMapContinuousShot));
std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapImageSize; // std::map<std::string, std::reference_wrapper<int>> innerMapBurstPhotoInterval;
innerMapImageSize.insert(std::make_pair("image_size", std::reference_wrapper<CHAR_STRING>(mAllData.imageSize))); // innerMapBurstPhotoInterval.insert(
mCfgMapString.insert(std::make_pair(IpcConfigKey::IMGAE_SIZE, innerMapImageSize)); // std::make_pair("burst_photo_interval", std::reference_wrapper<int>(mAllData.burstPhotoInterval)));
// mCfgMapInt.insert(std::make_pair(IpcConfigKey::BURST_PHOTO_INTERVAL, innerMapBurstPhotoInterval));
std::map<std::string, std::reference_wrapper<int>> innerMapVideoSize; // std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapImageSize;
innerMapVideoSize.insert(std::make_pair("video_size", std::reference_wrapper<int>(mAllData.videoSize))); // innerMapImageSize.insert(std::make_pair("image_size", std::reference_wrapper<CHAR_STRING>(mAllData.imageSize)));
mCfgMapInt.insert(std::make_pair(IpcConfigKey::VIDEO_SIZE, innerMapVideoSize)); // mCfgMapString.insert(std::make_pair(IpcConfigKey::IMGAE_SIZE, innerMapImageSize));
std::map<std::string, std::reference_wrapper<int>> innerMapInfraredLampPower; // std::map<std::string, std::reference_wrapper<int>> innerMapVideoSize;
innerMapInfraredLampPower.insert( // innerMapVideoSize.insert(std::make_pair("video_size", std::reference_wrapper<int>(mAllData.videoSize)));
std::make_pair("infrared_lamp_power", std::reference_wrapper<int>(mAllData.infraredIampPower))); // mCfgMapInt.insert(std::make_pair(IpcConfigKey::VIDEO_SIZE, innerMapVideoSize));
mCfgMapInt.insert(std::make_pair(IpcConfigKey::INFRARED_LAMP_POWER, innerMapInfraredLampPower));
std::map<std::string, std::reference_wrapper<int>> innerMapDelayed; // std::map<std::string, std::reference_wrapper<int>> innerMapInfraredLampPower;
innerMapDelayed.insert(std::make_pair("delayed", std::reference_wrapper<int>(mAllData.delayed))); // innerMapInfraredLampPower.insert(
mCfgMapInt.insert(std::make_pair(IpcConfigKey::PIR_DELAYED, innerMapDelayed)); // std::make_pair("infrared_lamp_power", std::reference_wrapper<int>(mAllData.infraredIampPower)));
// mCfgMapInt.insert(std::make_pair(IpcConfigKey::INFRARED_LAMP_POWER, innerMapInfraredLampPower));
std::map<std::string, std::reference_wrapper<int>> innerMapPirSensitivity; // std::map<std::string, std::reference_wrapper<int>> innerMapDelayed;
innerMapPirSensitivity.insert( // innerMapDelayed.insert(std::make_pair("delayed", std::reference_wrapper<int>(mAllData.delayed)));
std::make_pair("pir_sensitivity", std::reference_wrapper<int>(mAllData.pirSensitivity))); // mCfgMapInt.insert(std::make_pair(IpcConfigKey::PIR_DELAYED, innerMapDelayed));
mCfgMapInt.insert(std::make_pair(IpcConfigKey::PIR_SENSITIVITY, innerMapPirSensitivity));
std::map<std::string, std::reference_wrapper<bool>> innerMapStorageLoopSwitch; // std::map<std::string, std::reference_wrapper<int>> innerMapPirSensitivity;
innerMapStorageLoopSwitch.insert( // innerMapPirSensitivity.insert(
std::make_pair("storage_loop_switch", std::reference_wrapper<bool>(mAllData.storageLoopSwitch))); // std::make_pair("pir_sensitivity", std::reference_wrapper<int>(mAllData.pirSensitivity)));
mCfgMapBool.insert(std::make_pair(IpcConfigKey::STORAGE_LOOP_SWITCH, innerMapStorageLoopSwitch)); // mCfgMapInt.insert(std::make_pair(IpcConfigKey::PIR_SENSITIVITY, innerMapPirSensitivity));
std::map<std::string, std::reference_wrapper<bool>> innerMapFactoryReset; // std::map<std::string, std::reference_wrapper<bool>> innerMapStorageLoopSwitch;
innerMapFactoryReset.insert(std::make_pair("factory_reset", std::reference_wrapper<bool>(mAllData.factoryReset))); // innerMapStorageLoopSwitch.insert(
mCfgMapBool.insert(std::make_pair(IpcConfigKey::FACTORY_RESET_FLAG, innerMapFactoryReset)); // std::make_pair("storage_loop_switch", std::reference_wrapper<bool>(mAllData.storageLoopSwitch)));
// mCfgMapBool.insert(std::make_pair(IpcConfigKey::STORAGE_LOOP_SWITCH, innerMapStorageLoopSwitch));
std::map<std::string, std::reference_wrapper<bool>> innerMapFormattingSDCard; // std::map<std::string, std::reference_wrapper<bool>> innerMapFactoryReset;
innerMapFormattingSDCard.insert( // innerMapFactoryReset.insert(std::make_pair("factory_reset",
std::make_pair("formatting_SD_card", std::reference_wrapper<bool>(mAllData.formattingSDCard))); // std::reference_wrapper<bool>(mAllData.factoryReset)));
mCfgMapBool.insert(std::make_pair(IpcConfigKey::FORMATTING_SD_CARD, innerMapFormattingSDCard)); // mCfgMapBool.insert(std::make_pair(IpcConfigKey::FACTORY_RESET_FLAG, innerMapFactoryReset));
std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapDrakMode; // std::map<std::string, std::reference_wrapper<bool>> innerMapFormattingSDCard;
innerMapDrakMode.insert(std::make_pair("dark_mode", std::reference_wrapper<CHAR_STRING>(mAllData.darkMode))); // innerMapFormattingSDCard.insert(
mCfgMapString.insert(std::make_pair(IpcConfigKey::DARK_MODE, innerMapDrakMode)); // std::make_pair("formatting_SD_card", std::reference_wrapper<bool>(mAllData.formattingSDCard)));
// mCfgMapBool.insert(std::make_pair(IpcConfigKey::FORMATTING_SD_CARD, innerMapFormattingSDCard));
std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapWorkInterval; // std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapDrakMode;
innerMapWorkInterval.insert( // innerMapDrakMode.insert(std::make_pair("dark_mode", std::reference_wrapper<CHAR_STRING>(mAllData.darkMode)));
std::make_pair("work_interval", std::reference_wrapper<CHAR_STRING>(mAllData.workingInterval))); // mCfgMapString.insert(std::make_pair(IpcConfigKey::DARK_MODE, innerMapDrakMode));
mCfgMapString.insert(std::make_pair(IpcConfigKey::WORK_INTERVAL, innerMapWorkInterval));
std::map<std::string, std::reference_wrapper<short>> innerMapShort; // std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapWorkInterval;
innerMapShort.insert(std::make_pair("test_short", std::reference_wrapper<short>(mAllData.testShort))); // innerMapWorkInterval.insert(
mCfgMapShort.insert(std::make_pair(IpcConfigKey::TEST_SHORT, innerMapShort)); // std::make_pair("work_interval", std::reference_wrapper<CHAR_STRING>(mAllData.workingInterval)));
// mCfgMapString.insert(std::make_pair(IpcConfigKey::WORK_INTERVAL, innerMapWorkInterval));
std::map<std::string, std::reference_wrapper<long>> innerMapLong; // std::map<std::string, std::reference_wrapper<short>> innerMapShort;
innerMapLong.insert(std::make_pair("test_long", std::reference_wrapper<long>(mAllData.testLong))); // innerMapShort.insert(std::make_pair("test_short", std::reference_wrapper<short>(mAllData.testShort)));
mCfgMapLong.insert(std::make_pair(IpcConfigKey::TEST_LONG, innerMapLong)); // mCfgMapShort.insert(std::make_pair(IpcConfigKey::TEST_SHORT, innerMapShort));
std::map<std::string, std::reference_wrapper<long long>> innerMapLLong; // std::map<std::string, std::reference_wrapper<long>> innerMapLong;
innerMapLLong.insert(std::make_pair("test_llong", std::reference_wrapper<long long>(mAllData.testLLong))); // innerMapLong.insert(std::make_pair("test_long", std::reference_wrapper<long>(mAllData.testLong)));
mCfgMapLLong.insert(std::make_pair(IpcConfigKey::TEST_LLONG, innerMapLLong)); // mCfgMapLong.insert(std::make_pair(IpcConfigKey::TEST_LONG, innerMapLong));
std::map<std::string, std::reference_wrapper<char>> innerMapChar; // std::map<std::string, std::reference_wrapper<long long>> innerMapLLong;
innerMapChar.insert(std::make_pair("test_char", std::reference_wrapper<char>(mAllData.testChar))); // innerMapLLong.insert(std::make_pair("test_llong", std::reference_wrapper<long long>(mAllData.testLLong)));
mCfgMapChar.insert(std::make_pair(IpcConfigKey::TEST_CHAR, innerMapChar)); // mCfgMapLLong.insert(std::make_pair(IpcConfigKey::TEST_LLONG, innerMapLLong));
std::map<std::string, std::reference_wrapper<float>> innerMapFloat; // std::map<std::string, std::reference_wrapper<char>> innerMapChar;
innerMapFloat.insert(std::make_pair("test_float", std::reference_wrapper<float>(mAllData.testFloat))); // innerMapChar.insert(std::make_pair("test_char", std::reference_wrapper<char>(mAllData.testChar)));
mCfgMapFloat.insert(std::make_pair(IpcConfigKey::TEST_FLOAT, innerMapFloat)); // mCfgMapChar.insert(std::make_pair(IpcConfigKey::TEST_CHAR, innerMapChar));
// std::map<std::string, std::reference_wrapper<float>> innerMapFloat;
// innerMapFloat.insert(std::make_pair("test_float", std::reference_wrapper<float>(mAllData.testFloat)));
// mCfgMapFloat.insert(std::make_pair(IpcConfigKey::TEST_FLOAT, innerMapFloat));
} }
const StatusCode IpcConfigImpl::Init(void) const StatusCode IpcConfigImpl::Init(void)
{ {
@ -128,10 +158,18 @@ const StatusCode IpcConfigImpl::ConfigFileSave(void)
const int IpcConfigImpl::GetInt(const IpcConfigKey &key) const int IpcConfigImpl::GetInt(const IpcConfigKey &key)
{ {
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>>::iterator iter; // std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>>::iterator iter;
iter = mCfgMapInt.find(key); // iter = mCfgMapInt.find(key);
if (iter != mCfgMapInt.end() && CHECK_MAP(iter->second)) { // if (iter != mCfgMapInt.end() && CHECK_MAP(iter->second)) {
return iter->second.begin()->second; // return iter->second.begin()->second;
// }
// LogError("Can't find the key.\n");
// constexpr int UNKNOWN_CONFIG = -1;
// return UNKNOWN_CONFIG;
std::map<IpcConfigKey, std::map<std::string, int *>>::iterator iter;
iter = mCfgMapIntV2.find(key);
if (iter != mCfgMapIntV2.end() && CHECK_MAP(iter->second)) {
return *(iter->second.begin()->second);
} }
LogError("Can't find the key.\n"); LogError("Can't find the key.\n");
constexpr int UNKNOWN_CONFIG = -1; constexpr int UNKNOWN_CONFIG = -1;
@ -139,12 +177,22 @@ const int IpcConfigImpl::GetInt(const IpcConfigKey &key)
} }
void IpcConfigImpl::SetInt(const IpcConfigKey &key, const int &value) void IpcConfigImpl::SetInt(const IpcConfigKey &key, const int &value)
{ {
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>>::iterator iter; // std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>>::iterator iter;
iter = mCfgMapInt.find(key); // iter = mCfgMapInt.find(key);
if (iter != mCfgMapInt.end() && CHECK_MAP(iter->second)) { // if (iter != mCfgMapInt.end() && CHECK_MAP(iter->second)) {
iter->second.begin()->second.get() = value; // iter->second.begin()->second.get() = value;
const char *name = iter->second.begin()->first.c_str(); // const char *name = iter->second.begin()->first.c_str();
ConfigSetInt(mCfg, name, iter->second.begin()->second); // ConfigSetInt(mCfg, name, iter->second.begin()->second);
// mCfgChanged = CONFIG_HAS_CHANGED;
// }
// else {
// LogError("Can't find the key.\n");
// }
std::map<IpcConfigKey, std::map<std::string, int *>>::iterator iter;
iter = mCfgMapIntV2.find(key);
if (iter != mCfgMapIntV2.end() && CHECK_MAP(iter->second)) {
*(iter->second.begin()->second) = value;
ConfigSetInt(mCfg, iter->second.begin()->first.c_str(), *(iter->second.begin()->second));
mCfgChanged = CONFIG_HAS_CHANGED; mCfgChanged = CONFIG_HAS_CHANGED;
} }
else { else {
@ -228,10 +276,10 @@ void IpcConfigImpl::SetLLong(const IpcConfigKey &key, const long long &value)
} }
const char IpcConfigImpl::GetChar(const IpcConfigKey &key) const char IpcConfigImpl::GetChar(const IpcConfigKey &key)
{ {
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<char>>>::iterator iter; std::map<IpcConfigKey, std::map<std::string, char *>>::iterator iter;
iter = mCfgMapChar.find(key); iter = mCfgMapCharV2.find(key);
if (iter != mCfgMapChar.end() && CHECK_MAP(iter->second)) { if (iter != mCfgMapCharV2.end() && CHECK_MAP(iter->second)) {
return iter->second.begin()->second; return *(iter->second.begin()->second);
} }
LogError("Can't find the key.\n"); LogError("Can't find the key.\n");
constexpr char UNKNOWN_CONFIG = '\0'; constexpr char UNKNOWN_CONFIG = '\0';
@ -239,12 +287,12 @@ const char IpcConfigImpl::GetChar(const IpcConfigKey &key)
} }
void IpcConfigImpl::SetChar(const IpcConfigKey &key, const char &character) void IpcConfigImpl::SetChar(const IpcConfigKey &key, const char &character)
{ {
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<char>>>::iterator iter; std::map<IpcConfigKey, std::map<std::string, char *>>::iterator iter;
iter = mCfgMapChar.find(key); iter = mCfgMapCharV2.find(key);
if (iter != mCfgMapChar.end() && CHECK_MAP(iter->second)) { if (iter != mCfgMapCharV2.end() && CHECK_MAP(iter->second)) {
iter->second.begin()->second.get() = character; *(iter->second.begin()->second) = character;
const char *name = iter->second.begin()->first.c_str(); const char *name = iter->second.begin()->first.c_str();
ConfigSetChar(mCfg, name, iter->second.begin()->second); ConfigSetChar(mCfg, name, *(iter->second.begin()->second));
mCfgChanged = CONFIG_HAS_CHANGED; mCfgChanged = CONFIG_HAS_CHANGED;
} }
else { else {
@ -351,218 +399,289 @@ void IpcConfigImpl::SetBool(const IpcConfigKey &key, const bool &value)
} }
const std::string IpcConfigImpl::GetString(const IpcConfigKey &key) const std::string IpcConfigImpl::GetString(const IpcConfigKey &key)
{ {
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<CHAR_STRING>>>::iterator iter; std::map<IpcConfigKey, std::map<std::string, StringConfigPack>>::iterator iter;
iter = mCfgMapString.find(key); iter = mCfgMapStringV2.find(key);
if (iter != mCfgMapString.end() && CHECK_MAP(iter->second)) { if (iter != mCfgMapStringV2.end() && CHECK_MAP(iter->second)) {
const std::string sv(iter->second.begin()->second); // char[] --> const std::strinbg const std::string sv(iter->second.begin()->second.mValue); // char[] --> const std::strinbg
return sv; return sv;
} }
LogError("Can't find the key.\n"); LogError("Can't find the key.\n");
const std::string UNKNOWN_CONFIG = "undefine"; const std::string UNKNOWN_CONFIG = "undefine";
return UNKNOWN_CONFIG; return UNKNOWN_CONFIG;
} }
void IpcConfigImpl::SetString(const IpcConfigKey &key, const std::string string) void IpcConfigImpl::SetString(const IpcConfigKey &key, const std::string &string)
{ {
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<CHAR_STRING>>>::iterator iter; std::map<IpcConfigKey, std::map<std::string, StringConfigPack>>::iterator iter;
iter = mCfgMapString.find(key); iter = mCfgMapStringV2.find(key);
if (iter != mCfgMapString.end() && CHECK_MAP(iter->second)) { if (iter != mCfgMapStringV2.end() && CHECK_MAP(iter->second)) {
strncpy(iter->second.begin()->second, string.c_str(), sizeof(CHAR_STRING)); // const std::strinbg --> char[] if (string.length() > iter->second.begin()->second.mLength) {
const char *name = iter->second.begin()->first.c_str(); LogError("The string is too long. Your string is %s, the max length is %d\n",
ConfigSetString(mCfg, name, iter->second.begin()->second); string.c_str(),
iter->second.begin()->second.mLength);
return;
}
strncpy(iter->second.begin()->second.mValue, string.c_str(), iter->second.begin()->second.mLength);
ConfigSetString(mCfg, iter->second.begin()->first.c_str(), iter->second.begin()->second.mValue);
mCfgChanged = CONFIG_HAS_CHANGED; mCfgChanged = CONFIG_HAS_CHANGED;
} }
else { else {
LogError("Can't find the key.\n"); LogError("Can't find the key.\n");
} }
} }
WorkMode IpcConfigImpl::GetWorkMode(void)
{
return static_cast<WorkMode>(GetChar(IpcConfigKey::WORK_MODE));
}
void IpcConfigImpl::SetWorkMode(const WorkMode &mode)
{
SetChar(IpcConfigKey::WORK_MODE, static_cast<char>(mode));
}
void IpcConfigImpl::ReadAllConfigParameters(void) void IpcConfigImpl::ReadAllConfigParameters(void)
{ {
StatusCode workModeCode = ConfigGetInt(mCfg, "work_mode", &(mAllData.workMode)); {
if (StatusCodeEqual(workModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { const char *config = nullptr;
LogWarning("work_mode doesn't exist, will make it as default.\n"); StatusCode code = ConfigGetString(mCfg, CONFIG_WIFI_SSID, &config);
mCfgChanged = CONFIG_HAS_CHANGED; if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
mAllData.workMode = WORK_MODE_PIC; LogWarning("CONFIG_WIFI_SSID doesn't exist, will make it as default.\n");
ConfigSetInt(mCfg, "work_mode", mAllData.workMode); mCfgChanged = CONFIG_HAS_CHANGED;
} strncpy(mAllData.mWifiSsid, CONFIG_WIFI_SSID_DEFAULT, sizeof(mAllData.mWifiSsid));
ConfigSetString(mCfg, CONFIG_WIFI_SSID, mAllData.mWifiSsid);
StatusCode continuousShotCode = ConfigGetInt(mCfg, "continuous_shot", &(mAllData.continuousShot));
if (StatusCodeEqual(continuousShotCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("continuous_shot doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.continuousShot = CONTINUOUS_SHOT_ONE_PIC;
ConfigSetInt(mCfg, "continuous_shot", mAllData.continuousShot);
}
StatusCode burstPhotoIntervalCode = ConfigGetInt(mCfg, "burst_photo_interval", &(mAllData.burstPhotoInterval));
if (StatusCodeEqual(burstPhotoIntervalCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("burst_photo_interval doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.burstPhotoInterval = BURST_PHOTO_INTERVAL_DEFAULT;
ConfigSetInt(mCfg, "burst_photo_interval", mAllData.burstPhotoInterval);
}
const char *imageSizeString = nullptr;
StatusCode imageSizeCode = ConfigGetString(mCfg, "image_size", &(imageSizeString));
if (StatusCodeEqual(imageSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("image_size doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
char defaultImageSize[] = "320*320";
strncpy(mAllData.imageSize, defaultImageSize, sizeof(mAllData.imageSize));
ConfigSetString(mCfg, "image_size", mAllData.imageSize);
}
else {
if (nullptr != imageSizeString) {
strncpy(mAllData.imageSize, imageSizeString, sizeof(mAllData.imageSize));
} }
else { else {
LogError("image_size get failed.\n"); if (nullptr != config) {
strncpy(mAllData.mWifiSsid, config, sizeof(mAllData.mWifiSsid));
}
else {
LogError("CONFIG_WIFI_SSID get failed.\n");
}
} }
} }
{
StatusCode videoSizeCode = ConfigGetInt(mCfg, "video_size", &(mAllData.videoSize)); const char *config = nullptr;
if (StatusCodeEqual(videoSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { StatusCode code = ConfigGetString(mCfg, CONFIG_WIFI_PASSWORD, &config);
LogWarning("video_size doesn't exist, will make it as default.\n"); if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
mCfgChanged = CONFIG_HAS_CHANGED; LogWarning("CONFIG_WIFI_PASSWORD doesn't exist, will make it as default.\n");
mAllData.videoSize = VIDEO_SIZE_15; mCfgChanged = CONFIG_HAS_CHANGED;
ConfigSetInt(mCfg, "video_size", mAllData.videoSize); strncpy(mAllData.mWifiPassword, CONFIG_WIFI_PASSWORD_DEFAULT, sizeof(mAllData.mWifiPassword));
} ConfigSetString(mCfg, CONFIG_WIFI_PASSWORD, mAllData.mWifiPassword);
StatusCode infraredIampPowerCode = ConfigGetInt(mCfg, "infrared_lamp_power", &(mAllData.infraredIampPower));
if (StatusCodeEqual(infraredIampPowerCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("infrared_lamp_power doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.infraredIampPower = INFRARED_IAMP_POWER_MID;
ConfigSetInt(mCfg, "infrared_lamp_power", mAllData.infraredIampPower);
}
StatusCode delayedCode = ConfigGetInt(mCfg, "delayed", &(mAllData.delayed));
if (StatusCodeEqual(delayedCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("delayed doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.delayed = DELAYED_DEFAULT;
ConfigSetInt(mCfg, "delayed", mAllData.delayed);
}
StatusCode pirSensitivityCode = ConfigGetInt(mCfg, "pir_sensitivity", &(mAllData.pirSensitivity));
if (StatusCodeEqual(pirSensitivityCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("pir_sensitivity doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.pirSensitivity = PIR_SENSITIVITY_DEFAULT;
ConfigSetInt(mCfg, "pir_sensitivity", mAllData.pirSensitivity);
}
StatusCode storageLoopSwitchCode = ConfigGetBool(mCfg, "storage_loop_switch", &(mAllData.storageLoopSwitch));
if (StatusCodeEqual(storageLoopSwitchCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("storage_loop_switch doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
constexpr bool storageLoopSwitch = true;
mAllData.storageLoopSwitch = storageLoopSwitch;
ConfigSetBool(mCfg, "storage_loop_switch", mAllData.storageLoopSwitch);
}
StatusCode factoryResetCode = ConfigGetBool(mCfg, "factory_reset", &(mAllData.factoryReset));
if (StatusCodeEqual(factoryResetCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("factory_resetCode doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
constexpr bool factoryReset = true;
mAllData.factoryReset = factoryReset;
ConfigSetBool(mCfg, "factory_reset", mAllData.factoryReset);
}
StatusCode formattingSDCardCode = ConfigGetBool(mCfg, "formatting_SD_card", &(mAllData.formattingSDCard));
if (StatusCodeEqual(formattingSDCardCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("formatting_SD_card doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
constexpr bool formattingSDCard = true;
mAllData.formattingSDCard = formattingSDCard;
ConfigSetBool(mCfg, "formatting_SD_card", mAllData.formattingSDCard);
}
const char *darkModeString = nullptr;
StatusCode darkModeCode = ConfigGetString(mCfg, "dark_mode", &(darkModeString));
if (StatusCodeEqual(darkModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("dark_mode doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
char defaultDarkMode[] = "19:00:00-07:00:00";
strncpy(mAllData.darkMode, defaultDarkMode, sizeof(mAllData.darkMode));
ConfigSetString(mCfg, "dark_mode", mAllData.darkMode);
}
else {
if (nullptr != darkModeString) {
strncpy(mAllData.darkMode, darkModeString, sizeof(mAllData.darkMode));
} }
else { else {
LogError("dark_mode get failed.\n"); if (nullptr != config) {
strncpy(mAllData.mWifiPassword, config, sizeof(mAllData.mWifiPassword));
}
else {
LogError("CONFIG_WIFI_PASSWORD get failed.\n");
}
} }
} }
{
const char *workIntervalString = nullptr; StatusCode code = ConfigGetChar(mCfg, CONFIG_WORK_MODE, &mAllData.mWorkMode);
StatusCode workIntervalCode = ConfigGetString(mCfg, "work_interval", &(workIntervalString)); if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
if (StatusCodeEqual(workIntervalCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { LogWarning("CONFIG_WORK_MODE doesn't exist, will make it as default.\n");
LogWarning("work_interval doesn't exist, will make it as default.\n"); mCfgChanged = CONFIG_HAS_CHANGED;
mCfgChanged = CONFIG_HAS_CHANGED; mAllData.mWorkMode = CONFIG_WORK_MODE_DEFAULT;
char defaultWorkInterval[] = "07:00:01-07:00:00"; ConfigSetChar(mCfg, CONFIG_WORK_MODE, mAllData.mWorkMode);
strncpy(mAllData.workingInterval, defaultWorkInterval, sizeof(mAllData.workingInterval)); }
ConfigSetString(mCfg, "work_interval", mAllData.workingInterval);
} }
else { {
if (nullptr != workIntervalString) { int config = -1;
strncpy(mAllData.workingInterval, workIntervalString, sizeof(mAllData.workingInterval)); StatusCode code = ConfigGetInt(mCfg, CONFIG_CONTINUE_SHOT, &config);
if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("CONFIG_CONTINUE_SHOT doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.mContinuousShot = CONFIG_CONTINUE_SHOT_DEFAULT;
ConfigSetInt(mCfg, CONFIG_CONTINUE_SHOT, mAllData.mContinuousShot);
} }
else { else {
LogError("work_interval get failed.\n"); mAllData.mContinuousShot = config;
} }
} }
StatusCode shortCode = ConfigGetShort(mCfg, "test_short", &(mAllData.testShort)); // StatusCode workModeCode = ConfigGetInt(mCfg, "work_mode", &(mAllData.mWorkMode));
if (StatusCodeEqual(shortCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { // if (StatusCodeEqual(workModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("test_short doesn't exist, will make it as default.\n"); // LogWarning("work_mode doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED; // mCfgChanged = CONFIG_HAS_CHANGED;
constexpr short DEFAULT_TEST_SHORT_NUM = 11; // mAllData.mWorkMode = MODE_PIC;
mAllData.testShort = DEFAULT_TEST_SHORT_NUM; // ConfigSetInt(mCfg, "work_mode", mAllData.mWorkMode);
ConfigSetShort(mCfg, "test_short", mAllData.testShort); // }
}
StatusCode longCode = ConfigGetLong(mCfg, "test_long", &(mAllData.testLong)); // StatusCode continuousShotCode = ConfigGetInt(mCfg, "continuous_shot", &(mAllData.mContinuousShot));
if (StatusCodeEqual(longCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { // if (StatusCodeEqual(continuousShotCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("test_long doesn't exist, will make it as default.\n"); // LogWarning("continuous_shot doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED; // mCfgChanged = CONFIG_HAS_CHANGED;
constexpr long DEFAULT_TEST_LONG_NUM = 12; // mAllData.mContinuousShot = CONTINUOUS_SHOT_ONE_PIC;
mAllData.testLong = DEFAULT_TEST_LONG_NUM; // ConfigSetInt(mCfg, "continuous_shot", mAllData.mContinuousShot);
ConfigSetLong(mCfg, "test_long", mAllData.testLong); // }
}
StatusCode llongCode = ConfigGetLLong(mCfg, "test_llong", &(mAllData.testLLong)); // StatusCode burstPhotoIntervalCode = ConfigGetInt(mCfg, "burst_photo_interval", &(mAllData.burstPhotoInterval));
if (StatusCodeEqual(llongCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { // if (StatusCodeEqual(burstPhotoIntervalCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("test_llong doesn't exist, will make it as default.\n"); // LogWarning("burst_photo_interval doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED; // mCfgChanged = CONFIG_HAS_CHANGED;
constexpr long long DEFAULT_TEST_LLONG_NUM = 13; // mAllData.burstPhotoInterval = BURST_PHOTO_INTERVAL_DEFAULT;
mAllData.testLLong = DEFAULT_TEST_LLONG_NUM; // ConfigSetInt(mCfg, "burst_photo_interval", mAllData.burstPhotoInterval);
ConfigSetLLong(mCfg, "test_llong", mAllData.testLLong); // }
}
StatusCode charCode = ConfigGetChar(mCfg, "test_char", &(mAllData.testChar)); // const char *imageSizeString = nullptr;
if (StatusCodeEqual(charCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { // StatusCode imageSizeCode = ConfigGetString(mCfg, "image_size", &(imageSizeString));
LogWarning("test_char doesn't exist, will make it as default.\n"); // if (StatusCodeEqual(imageSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
mCfgChanged = CONFIG_HAS_CHANGED; // LogWarning("image_size doesn't exist, will make it as default.\n");
constexpr char DEFAULT_TEST_CHAR_NUM = 'B'; // mCfgChanged = CONFIG_HAS_CHANGED;
mAllData.testChar = DEFAULT_TEST_CHAR_NUM; // char defaultImageSize[] = "320*320";
ConfigSetChar(mCfg, "test_char", mAllData.testChar); // strncpy(mAllData.imageSize, defaultImageSize, sizeof(mAllData.imageSize));
} // ConfigSetString(mCfg, "image_size", mAllData.imageSize);
// }
// else {
// if (nullptr != imageSizeString) {
// strncpy(mAllData.imageSize, imageSizeString, sizeof(mAllData.imageSize));
// }
// else {
// LogError("image_size get failed.\n");
// }
// }
StatusCode floatCode = ConfigGetFloat(mCfg, "test_float", &(mAllData.testFloat)); // StatusCode videoSizeCode = ConfigGetInt(mCfg, "video_size", &(mAllData.videoSize));
if (StatusCodeEqual(floatCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { // if (StatusCodeEqual(videoSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
LogWarning("test_float doesn't exist, will make it as default.\n"); // LogWarning("video_size doesn't exist, will make it as default.\n");
mCfgChanged = CONFIG_HAS_CHANGED; // mCfgChanged = CONFIG_HAS_CHANGED;
constexpr float DEFAULT_TEST_FLOAT_NUM = 1.123456; // mAllData.videoSize = VIDEO_SIZE_15;
mAllData.testFloat = DEFAULT_TEST_FLOAT_NUM; // ConfigSetInt(mCfg, "video_size", mAllData.videoSize);
ConfigSetFloat(mCfg, "test_float", mAllData.testFloat); // }
}
if (CONFIG_HAS_CHANGED == mCfgChanged) { // StatusCode infraredIampPowerCode = ConfigGetInt(mCfg, "infrared_lamp_power", &(mAllData.infraredIampPower));
LogInfo("Save the config file.\n"); // if (StatusCodeEqual(infraredIampPowerCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
mCfgChanged = CONFIG_HAS_NOT_CHANGED; // LogWarning("infrared_lamp_power doesn't exist, will make it as default.\n");
ConfigSaveFile(mCfg); // mCfgChanged = CONFIG_HAS_CHANGED;
} // mAllData.infraredIampPower = INFRARED_IAMP_POWER_MID;
// ConfigSetInt(mCfg, "infrared_lamp_power", mAllData.infraredIampPower);
// }
// StatusCode delayedCode = ConfigGetInt(mCfg, "delayed", &(mAllData.delayed));
// if (StatusCodeEqual(delayedCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("delayed doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// mAllData.delayed = DELAYED_DEFAULT;
// ConfigSetInt(mCfg, "delayed", mAllData.delayed);
// }
// StatusCode pirSensitivityCode = ConfigGetInt(mCfg, "pir_sensitivity", &(mAllData.pirSensitivity));
// if (StatusCodeEqual(pirSensitivityCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("pir_sensitivity doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// mAllData.pirSensitivity = PIR_SENSITIVITY_DEFAULT;
// ConfigSetInt(mCfg, "pir_sensitivity", mAllData.pirSensitivity);
// }
// StatusCode storageLoopSwitchCode = ConfigGetBool(mCfg, "storage_loop_switch", &(mAllData.storageLoopSwitch));
// if (StatusCodeEqual(storageLoopSwitchCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("storage_loop_switch doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr bool storageLoopSwitch = true;
// mAllData.storageLoopSwitch = storageLoopSwitch;
// ConfigSetBool(mCfg, "storage_loop_switch", mAllData.storageLoopSwitch);
// }
// StatusCode factoryResetCode = ConfigGetBool(mCfg, "factory_reset", &(mAllData.factoryReset));
// if (StatusCodeEqual(factoryResetCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("factory_resetCode doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr bool factoryReset = true;
// mAllData.factoryReset = factoryReset;
// ConfigSetBool(mCfg, "factory_reset", mAllData.factoryReset);
// }
// StatusCode formattingSDCardCode = ConfigGetBool(mCfg, "formatting_SD_card", &(mAllData.formattingSDCard));
// if (StatusCodeEqual(formattingSDCardCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("formatting_SD_card doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr bool formattingSDCard = true;
// mAllData.formattingSDCard = formattingSDCard;
// ConfigSetBool(mCfg, "formatting_SD_card", mAllData.formattingSDCard);
// }
// const char *darkModeString = nullptr;
// StatusCode darkModeCode = ConfigGetString(mCfg, "dark_mode", &(darkModeString));
// if (StatusCodeEqual(darkModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("dark_mode doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// char defaultDarkMode[] = "19:00:00-07:00:00";
// strncpy(mAllData.darkMode, defaultDarkMode, sizeof(mAllData.darkMode));
// ConfigSetString(mCfg, "dark_mode", mAllData.darkMode);
// }
// else {
// if (nullptr != darkModeString) {
// strncpy(mAllData.darkMode, darkModeString, sizeof(mAllData.darkMode));
// }
// else {
// LogError("dark_mode get failed.\n");
// }
// }
// const char *workIntervalString = nullptr;
// StatusCode workIntervalCode = ConfigGetString(mCfg, "work_interval", &(workIntervalString));
// if (StatusCodeEqual(workIntervalCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("work_interval doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// char defaultWorkInterval[] = "07:00:01-07:00:00";
// strncpy(mAllData.workingInterval, defaultWorkInterval, sizeof(mAllData.workingInterval));
// ConfigSetString(mCfg, "work_interval", mAllData.workingInterval);
// }
// else {
// if (nullptr != workIntervalString) {
// strncpy(mAllData.workingInterval, workIntervalString, sizeof(mAllData.workingInterval));
// }
// else {
// LogError("work_interval get failed.\n");
// }
// }
// StatusCode shortCode = ConfigGetShort(mCfg, "test_short", &(mAllData.testShort));
// if (StatusCodeEqual(shortCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("test_short doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr short DEFAULT_TEST_SHORT_NUM = 11;
// mAllData.testShort = DEFAULT_TEST_SHORT_NUM;
// ConfigSetShort(mCfg, "test_short", mAllData.testShort);
// }
// StatusCode longCode = ConfigGetLong(mCfg, "test_long", &(mAllData.testLong));
// if (StatusCodeEqual(longCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("test_long doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr long DEFAULT_TEST_LONG_NUM = 12;
// mAllData.testLong = DEFAULT_TEST_LONG_NUM;
// ConfigSetLong(mCfg, "test_long", mAllData.testLong);
// }
// StatusCode llongCode = ConfigGetLLong(mCfg, "test_llong", &(mAllData.testLLong));
// if (StatusCodeEqual(llongCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("test_llong doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr long long DEFAULT_TEST_LLONG_NUM = 13;
// mAllData.testLLong = DEFAULT_TEST_LLONG_NUM;
// ConfigSetLLong(mCfg, "test_llong", mAllData.testLLong);
// }
// StatusCode charCode = ConfigGetChar(mCfg, "test_char", &(mAllData.testChar));
// if (StatusCodeEqual(charCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("test_char doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr char DEFAULT_TEST_CHAR_NUM = 'B';
// mAllData.testChar = DEFAULT_TEST_CHAR_NUM;
// ConfigSetChar(mCfg, "test_char", mAllData.testChar);
// }
// StatusCode floatCode = ConfigGetFloat(mCfg, "test_float", &(mAllData.testFloat));
// if (StatusCodeEqual(floatCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
// LogWarning("test_float doesn't exist, will make it as default.\n");
// mCfgChanged = CONFIG_HAS_CHANGED;
// constexpr float DEFAULT_TEST_FLOAT_NUM = 1.123456;
// mAllData.testFloat = DEFAULT_TEST_FLOAT_NUM;
// ConfigSetFloat(mCfg, "test_float", mAllData.testFloat);
// }
// if (CONFIG_HAS_CHANGED == mCfgChanged) {
// LogInfo("Save the config file.\n");
// mCfgChanged = CONFIG_HAS_NOT_CHANGED;
// ConfigSaveFile(mCfg);
// }
} }

25
middleware/IpcConfig/src/IpcConfigImpl.h
View File

@ -21,15 +21,23 @@
#include <memory> #include <memory>
constexpr bool CONFIG_HAS_CHANGED = true; constexpr bool CONFIG_HAS_CHANGED = true;
constexpr bool CONFIG_HAS_NOT_CHANGED = false; constexpr bool CONFIG_HAS_NOT_CHANGED = false;
constexpr unsigned int WIFI_SSID_BUFF_SIZE = 64;
constexpr unsigned int WIFI_PASSWORD_BUFF_SIZE = 8;
constexpr char CONFIG_WORK_MODE_DEFAULT = static_cast<char>(WorkMode::MODE_PIC);
constexpr int CONFIG_CONTINUE_SHOT_DEFAULT = 1;
typedef char CHAR_STRING[64]; typedef char CHAR_STRING[64];
typedef struct Config_s typedef struct string_config_pack
{
unsigned int mLength;
char *mValue;
} StringConfigPack;
typedef struct __attribute__((packed)) Config_s
{ {
bool storageLoopSwitch; bool storageLoopSwitch;
bool factoryReset; bool factoryReset;
bool formattingSDCard; bool formattingSDCard;
int workMode; char mWorkMode;
int continuousShot; int mContinuousShot;
int burstPhotoInterval; int burstPhotoInterval;
int videoSize; int videoSize;
int infraredIampPower; int infraredIampPower;
@ -43,6 +51,8 @@ typedef struct Config_s
CHAR_STRING imageSize; CHAR_STRING imageSize;
CHAR_STRING darkMode; CHAR_STRING darkMode;
CHAR_STRING workingInterval; CHAR_STRING workingInterval;
char mWifiSsid[WIFI_SSID_BUFF_SIZE + 1];
char mWifiPassword[WIFI_PASSWORD_BUFF_SIZE + 1];
} Config_s; } Config_s;
class MapInt class MapInt
{ {
@ -77,7 +87,9 @@ public:
const bool GetBool(const IpcConfigKey &key) override; const bool GetBool(const IpcConfigKey &key) override;
void SetBool(const IpcConfigKey &key, const bool &value) override; void SetBool(const IpcConfigKey &key, const bool &value) override;
const std::string GetString(const IpcConfigKey &key) override; const std::string GetString(const IpcConfigKey &key) override;
void SetString(const IpcConfigKey &key, const std::string string) override; void SetString(const IpcConfigKey &key, const std::string &string) override;
WorkMode GetWorkMode(void) override;
void SetWorkMode(const WorkMode &mode) override;
private: private:
void ReadAllConfigParameters(void); void ReadAllConfigParameters(void);
@ -87,14 +99,17 @@ private:
void *mCfg; void *mCfg;
Config_s mAllData; Config_s mAllData;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>> mCfgMapInt; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<int>>> mCfgMapInt;
std::map<IpcConfigKey, std::map<std::string, int *>> mCfgMapIntV2;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<short>>> mCfgMapShort; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<short>>> mCfgMapShort;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long>>> mCfgMapLong; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long>>> mCfgMapLong;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long long>>> mCfgMapLLong; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<long long>>> mCfgMapLLong;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<char>>> mCfgMapChar; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<char>>> mCfgMapChar;
std::map<IpcConfigKey, std::map<std::string, char *>> mCfgMapCharV2;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<float>>> mCfgMapFloat; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<float>>> mCfgMapFloat;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<double>>> mCfgMapDouble; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<double>>> mCfgMapDouble;
std::map<IpcConfigKey, std::reference_wrapper<long double>> mCfgMapLongDouble; std::map<IpcConfigKey, std::reference_wrapper<long double>> mCfgMapLongDouble;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<bool>>> mCfgMapBool; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<bool>>> mCfgMapBool;
std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<CHAR_STRING>>> mCfgMapString; std::map<IpcConfigKey, std::map<std::string, std::reference_wrapper<CHAR_STRING>>> mCfgMapString;
std::map<IpcConfigKey, std::map<std::string, StringConfigPack>> mCfgMapStringV2;
}; };
#endif #endif

2
test/middleware/IpcConfig/CMakeLists.txt
View File

@ -10,7 +10,9 @@ include_directories(
${UTILS_SOURCE_PATH}/Log/include ${UTILS_SOURCE_PATH}/Log/include
${UTILS_SOURCE_PATH}/StatusCode/include ${UTILS_SOURCE_PATH}/StatusCode/include
${UTILS_SOURCE_PATH}/LinuxApi/include ${UTILS_SOURCE_PATH}/LinuxApi/include
${UTILS_SOURCE_PATH}/ConfigBase/include
${MIDDLEWARE_SOURCE_PATH}/IpcConfig/include ${MIDDLEWARE_SOURCE_PATH}/IpcConfig/include
${MIDDLEWARE_SOURCE_PATH}/IpcConfig/src
${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googletest/include ${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googletest/include
${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googlemock/include ${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googlemock/include
) )

79
test/middleware/IpcConfig/src/IpcConfig_Test.cpp
View File

@ -1,8 +1,11 @@
#include "IIpcConfig.h" #include "IIpcConfig.h"
#include "ILog.h" #include "ILog.h"
#include "IpcConfigImpl.h"
#include "LinuxApi.h" #include "LinuxApi.h"
// #include <gmock/gmock.h> // #include <gmock/gmock.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
extern const char *CONFIG_WIFI_SSID_DEFAULT;
extern const char *CONFIG_WIFI_PASSWORD_DEFAULT;
namespace IpcConfigTest namespace IpcConfigTest
{ {
// ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigDemo.Demo // ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigDemo.Demo
@ -15,7 +18,7 @@ TEST(IpcConfigDemo, Demo)
const int workMode = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::WORK_MODE); const int workMode = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::WORK_MODE);
LogInfo("Get workMode = %d\n", workMode); LogInfo("Get workMode = %d\n", workMode);
const int wworkMode = WORK_MODE_PIC_VIDEO; const int wworkMode = static_cast<int>(WorkMode::MODE_PIC_VIDEO);
IIpcConfig::GetInstance()->SetInt(IpcConfigKey::WORK_MODE, wworkMode); IIpcConfig::GetInstance()->SetInt(IpcConfigKey::WORK_MODE, wworkMode);
const int continuousShot = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::CONTINUOUS_SHOT); const int continuousShot = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::CONTINUOUS_SHOT);
@ -151,8 +154,78 @@ private:
} }
} }
}; };
// ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigTest.Wifi // ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigTest.HS_RH_UNIT_IpcConfig_AUTO_WifiSsid
TEST_F(IpcConfigTest, Wifi) TEST_F(IpcConfigTest, HS_RH_UNIT_IpcConfig_AUTO_WifiSsid)
{ {
const char *MODIFIED_STRING = "modified_string";
const char *MODIFIED_STRING_SHORTER = "modified";
const char *LONG_STRING =
"LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL"
"LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL";
std::string config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_SSID);
LogInfo("Get wifi ssid = %s\n", config.c_str());
EXPECT_STREQ(config.c_str(), CONFIG_WIFI_SSID_DEFAULT);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_SSID, MODIFIED_STRING);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_SSID);
LogInfo("Get wifiSsid = %s\n", config.c_str());
EXPECT_STREQ(config.c_str(), MODIFIED_STRING);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_SSID, LONG_STRING);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_SSID);
EXPECT_STREQ(config.c_str(), MODIFIED_STRING);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_SSID, "");
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_SSID);
EXPECT_STREQ(config.c_str(), "");
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_SSID, MODIFIED_STRING_SHORTER);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_SSID);
EXPECT_STREQ(config.c_str(), MODIFIED_STRING_SHORTER);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_SSID, MODIFIED_STRING);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_SSID);
EXPECT_STREQ(config.c_str(), MODIFIED_STRING);
}
// ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigTest.HS_RH_UNIT_IpcConfig_AUTO_WifiPassword
TEST_F(IpcConfigTest, HS_RH_UNIT_IpcConfig_AUTO_WifiPassword)
{
const char *MODIFIED_STRING = "99999999";
const char *MODIFIED_STRING_SHORTER = "999";
const char *LONG_STRING =
"LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL"
"LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL";
std::string config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_PASSWORD);
LogInfo("Get wifi password = %s\n", config.c_str());
EXPECT_STREQ(config.c_str(), CONFIG_WIFI_PASSWORD_DEFAULT);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_PASSWORD, MODIFIED_STRING);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_PASSWORD);
LogInfo("Get wifi password = %s\n", config.c_str());
EXPECT_STREQ(config.c_str(), MODIFIED_STRING);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_PASSWORD, LONG_STRING);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_PASSWORD);
EXPECT_STREQ(config.c_str(), MODIFIED_STRING);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_PASSWORD, "");
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_PASSWORD);
EXPECT_STREQ(config.c_str(), "");
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_PASSWORD, MODIFIED_STRING_SHORTER);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_PASSWORD);
EXPECT_STREQ(config.c_str(), MODIFIED_STRING_SHORTER);
IIpcConfig::GetInstance()->SetString(IpcConfigKey::WIFI_PASSWORD, MODIFIED_STRING);
config = IIpcConfig::GetInstance()->GetString(IpcConfigKey::WIFI_PASSWORD);
EXPECT_STREQ(config.c_str(), MODIFIED_STRING);
}
// ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigTest.HS_RH_UNIT_IpcConfig_AUTO_WorkMode
TEST_F(IpcConfigTest, HS_RH_UNIT_IpcConfig_AUTO_WorkMode)
{
WorkMode config = IIpcConfig::GetInstance()->GetWorkMode();
EXPECT_EQ(static_cast<int>(config), static_cast<int>(CONFIG_WORK_MODE_DEFAULT));
IIpcConfig::GetInstance()->SetWorkMode(WorkMode::MODE_PIC_VIDEO);
config = IIpcConfig::GetInstance()->GetWorkMode();
EXPECT_EQ(static_cast<int>(config), static_cast<int>(WorkMode::MODE_PIC_VIDEO));
}
// ../output_files/test/bin/IpcConfigTest --gtest_filter=IpcConfigTest.HS_RH_UNIT_IpcConfig_AUTO_ContinueShot
TEST_F(IpcConfigTest, HS_RH_UNIT_IpcConfig_AUTO_ContinueShot)
{
int config = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::CONTINUOUS_SHOT);
EXPECT_EQ(config, CONFIG_CONTINUE_SHOT_DEFAULT);
IIpcConfig::GetInstance()->SetInt(IpcConfigKey::CONTINUOUS_SHOT, 2);
config = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::CONTINUOUS_SHOT);
EXPECT_EQ(config, 2);
} }
} // namespace IpcConfigTest } // namespace IpcConfigTest