diff --git a/middleware/IpcConfig/include/IIpcConfig.h b/middleware/IpcConfig/include/IIpcConfig.h index 81f211b..2f271d6 100644 --- a/middleware/IpcConfig/include/IIpcConfig.h +++ b/middleware/IpcConfig/include/IIpcConfig.h @@ -21,17 +21,75 @@ enum class IpcConfigKey { - TEST_NUM = 0, + KEY_WORK_MODE = 0, + KEY_CONTINUOUS_SHOT, + KEY_BURST_PHOTO_INTERVAL, + KEY_IMGAE_SIZE, + KEY_VIDEO_SIZE, + KEY_INFRARED_LAMP_POWER, + KEY_DELAYED, + KEY_PIR_SENSITIVITY, + KEY_STORAGE_LOOP_SWITCH, + KEY_FACTORY_RESET_FLAG, + KEY_FORMATTING_SD_CARD, + KEY_DARK_MODE, + KEY_WORK_INTERVAL, TEST_SHORT, TEST_LONG, TEST_LLONG, TEST_CHAR, TEST_BOOL, TEST_FLOAT, - TEST_DOUBLE, - TEST_STRING, END }; +enum WorkMode +{ + WORK_MODE_PIC = 0, + WORK_MODE_PIC_VIDEO, + WORK_MODE_END, +}; +enum ContinuousShot +{ + CONTINUOUS_SHOT_ONE_PIC = 1, + CONTINUOUS_SHOT_TWO_PIC, + CONTINUOUS_SHOT_THREE_PIC, + CONTINUOUS_SHOT_END, +}; +enum BurstPhotoInterval +{ + BURST_PHOTO_INTERVAL_MIN = 0, + BURST_PHOTO_INTERVAL_DEFAULT = 5, + BURST_PHOTO_INTERVAL_MAX = 99, + BURST_PHOTO_INTERVAL_END, +}; +enum VideoSize +{ + VIDEO_SIZE_10 = 10, + VIDEO_SIZE_15 = 15, + VIDEO_SIZE_END, +}; + +enum InfraredIampPower +{ + INFRARED_IAMP_POWER_LOW = 0, + INFRARED_IAMP_POWER_MID, + INFRARED_IAMP_POWER_HIGH, + INFRARED_IAMP_POWER_END, +}; +enum Delayed +{ + DELAYED_MIN = 0, + DELAYED_DEFAULT = 5, + DELAYED_MAX = 99, + DELAYED_END, +}; +enum PirSensitivity +{ + PIR_SENSITIVITY_MIN = 0, + PIR_SENSITIVITY_DEFAULT = 5, + PIR_SENSITIVITY_MAX = 9, + PIR_SENSITIVITY_END, +}; class IIpcConfig { diff --git a/middleware/IpcConfig/src/IpcConfig.cpp b/middleware/IpcConfig/src/IpcConfig.cpp index d30494c..50cb272 100644 --- a/middleware/IpcConfig/src/IpcConfig.cpp +++ b/middleware/IpcConfig/src/IpcConfig.cpp @@ -22,9 +22,64 @@ IpcConfig::IpcConfig() { mCfgChanged = CONFIG_HAS_NOT_CHANGED; - std::map> innerMapInt; - innerMapInt.insert(std::make_pair("test_num", std::reference_wrapper(mAllData.testNum))); - mCfgMapInt.insert(std::make_pair(IpcConfigKey::TEST_NUM, innerMapInt)); + std::map> innerMapWorkMode; + innerMapWorkMode.insert(std::make_pair("work_mode", std::reference_wrapper(mAllData.workMode))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_WORK_MODE, innerMapWorkMode)); + + std::map> innerMapContinuousShot; + innerMapContinuousShot.insert( + std::make_pair("continuous_shot", std::reference_wrapper(mAllData.continuousShot))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_CONTINUOUS_SHOT, innerMapContinuousShot)); + + std::map> innerMapBurstPhotoInterval; + innerMapBurstPhotoInterval.insert( + std::make_pair("burst_photo_interval", std::reference_wrapper(mAllData.burstPhotoInterval))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_BURST_PHOTO_INTERVAL, innerMapBurstPhotoInterval)); + + std::map> innerMapImageSize; + innerMapImageSize.insert(std::make_pair("image_size", std::reference_wrapper(mAllData.imageSize))); + mCfgMapString.insert(std::make_pair(IpcConfigKey::KEY_IMGAE_SIZE, innerMapImageSize)); + + std::map> innerMapVideoSize; + innerMapVideoSize.insert(std::make_pair("video_size", std::reference_wrapper(mAllData.videoSize))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_VIDEO_SIZE, innerMapVideoSize)); + + std::map> innerMapInfraredLampPower; + innerMapInfraredLampPower.insert( + std::make_pair("infrared_lamp_power", std::reference_wrapper(mAllData.infraredIampPower))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_INFRARED_LAMP_POWER, innerMapInfraredLampPower)); + + std::map> innerMapDelayed; + innerMapDelayed.insert(std::make_pair("delayed", std::reference_wrapper(mAllData.delayed))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_DELAYED, innerMapDelayed)); + + std::map> innerMapPirSensitivity; + innerMapPirSensitivity.insert( + std::make_pair("pir_sensitivity", std::reference_wrapper(mAllData.pirSensitivity))); + mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_PIR_SENSITIVITY, innerMapPirSensitivity)); + + std::map> innerMapStorageLoopSwitch; + innerMapStorageLoopSwitch.insert( + std::make_pair("storage_loop_switch", std::reference_wrapper(mAllData.storageLoopSwitch))); + mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_STORAGE_LOOP_SWITCH, innerMapStorageLoopSwitch)); + + std::map> innerMapFactoryReset; + innerMapFactoryReset.insert(std::make_pair("factory_reset", std::reference_wrapper(mAllData.factoryReset))); + mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_FACTORY_RESET_FLAG, innerMapFactoryReset)); + + std::map> innerMapFormattingSDCard; + innerMapFormattingSDCard.insert( + std::make_pair("formatting_SD_card", std::reference_wrapper(mAllData.formattingSDCard))); + mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_FORMATTING_SD_CARD, innerMapFormattingSDCard)); + + std::map> innerMapDrakMode; + innerMapDrakMode.insert(std::make_pair("dark_mode", std::reference_wrapper(mAllData.darkMode))); + mCfgMapString.insert(std::make_pair(IpcConfigKey::KEY_DARK_MODE, innerMapDrakMode)); + + std::map> innerMapWorkInterval; + innerMapWorkInterval.insert( + std::make_pair("work_interval", std::reference_wrapper(mAllData.workingInterval))); + mCfgMapString.insert(std::make_pair(IpcConfigKey::KEY_WORK_INTERVAL, innerMapWorkInterval)); std::map> innerMapShort; innerMapShort.insert(std::make_pair("test_short", std::reference_wrapper(mAllData.testShort))); @@ -42,21 +97,9 @@ IpcConfig::IpcConfig() innerMapChar.insert(std::make_pair("test_char", std::reference_wrapper(mAllData.testChar))); mCfgMapChar.insert(std::make_pair(IpcConfigKey::TEST_CHAR, innerMapChar)); - std::map> innerMapBool; - innerMapBool.insert(std::make_pair("test_bool", std::reference_wrapper(mAllData.testBool))); - mCfgMapBool.insert(std::make_pair(IpcConfigKey::TEST_BOOL, innerMapBool)); - std::map> innerMapFloat; innerMapFloat.insert(std::make_pair("test_float", std::reference_wrapper(mAllData.testFloat))); mCfgMapFloat.insert(std::make_pair(IpcConfigKey::TEST_FLOAT, innerMapFloat)); - - std::map> innerMapDouble; - innerMapDouble.insert(std::make_pair("test_double", std::reference_wrapper(mAllData.testDouble))); - mCfgMapDouble.insert(std::make_pair(IpcConfigKey::TEST_DOUBLE, innerMapDouble)); - - std::map> innerMapString; - innerMapString.insert(std::make_pair("test_string", std::reference_wrapper(mAllData.testString))); - mCfgMapString.insert(std::make_pair(IpcConfigKey::TEST_STRING, innerMapString)); } const StatusCode IpcConfig::Init(void) { @@ -332,13 +375,126 @@ void IpcConfig::SetString(const IpcConfigKey &key, const std::string string) void IpcConfig::ReadAllConfigParameters(void) { - StatusCode code = ConfigGetInt(mCfg, "test_num", &(mAllData.testNum)); - if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) { - LogWarning("test_num doesn't exist, will make it as default.\n"); + StatusCode workModeCode = ConfigGetInt(mCfg, "work_mode", &(mAllData.workMode)); + if (StatusCodeEqual(workModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { + LogWarning("work_mode doesn't exist, will make it as default.\n"); mCfgChanged = CONFIG_HAS_CHANGED; - constexpr int DEFAULT_TEST_NUM = 10; - mAllData.testNum = DEFAULT_TEST_NUM; - ConfigSetInt(mCfg, "test_num", mAllData.testNum); + mAllData.workMode = WORK_MODE_PIC; + ConfigSetInt(mCfg, "work_mode", mAllData.workMode); + } + + 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 = NULL; + 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 { + strncpy(mAllData.imageSize, imageSizeString, sizeof(mAllData.imageSize)); + } + + StatusCode videoSizeCode = ConfigGetInt(mCfg, "video_size", &(mAllData.videoSize)); + if (StatusCodeEqual(videoSizeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { + LogWarning("video_size doesn't exist, will make it as default.\n"); + mCfgChanged = CONFIG_HAS_CHANGED; + mAllData.videoSize = VIDEO_SIZE_15; + ConfigSetInt(mCfg, "video_size", mAllData.videoSize); + } + + 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 = NULL; + 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 { + strncpy(mAllData.darkMode, darkModeString, sizeof(mAllData.darkMode)); + } + + const char *workIntervalString = NULL; + 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 { + strncpy(mAllData.workingInterval, workIntervalString, sizeof(mAllData.workingInterval)); } StatusCode shortCode = ConfigGetShort(mCfg, "test_short", &(mAllData.testShort)); @@ -377,15 +533,6 @@ void IpcConfig::ReadAllConfigParameters(void) ConfigSetChar(mCfg, "test_char", mAllData.testChar); } - StatusCode boolCode = ConfigGetBool(mCfg, "test_bool", &(mAllData.testBool)); - if (StatusCodeEqual(boolCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { - LogWarning("test_bool doesn't exist, will make it as default.\n"); - mCfgChanged = CONFIG_HAS_CHANGED; - constexpr bool DEFAULT_TEST_BOOL_NUM = true; - mAllData.testBool = DEFAULT_TEST_BOOL_NUM; - ConfigSetBool(mCfg, "test_bool", mAllData.testBool); - } - 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"); @@ -395,28 +542,6 @@ void IpcConfig::ReadAllConfigParameters(void) ConfigSetFloat(mCfg, "test_float", mAllData.testFloat); } - StatusCode doubleCode = ConfigGetDouble(mCfg, "test_double", &(mAllData.testDouble)); - if (StatusCodeEqual(doubleCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { - LogWarning("test_double doesn't exist, will make it as default.\n"); - mCfgChanged = CONFIG_HAS_CHANGED; - constexpr double DEFAULT_TEST_DOUBLE_NUM = 3.123456; - mAllData.testDouble = DEFAULT_TEST_DOUBLE_NUM; - ConfigSetDouble(mCfg, "test_double", mAllData.testDouble); - } - - const char *testString = NULL; - StatusCode stringCode = ConfigGetString(mCfg, "test_string", &(testString)); - if (StatusCodeEqual(stringCode, "CONFIG_CODE_PARAM_NOT_EXIST")) { - LogWarning("test_string doesn't exist, will make it as default.\n"); - mCfgChanged = CONFIG_HAS_CHANGED; - char DEFAULT_TEST_STRING[] = "undefine"; - strncpy(mAllData.testString, DEFAULT_TEST_STRING, sizeof(mAllData.testString)); - ConfigSetString(mCfg, "test_string", mAllData.testString); - } - else { - strncpy(mAllData.testString, testString, sizeof(mAllData.testString)); - } - if (CONFIG_HAS_CHANGED == mCfgChanged) { LogInfo("Save the config file.\n"); mCfgChanged = CONFIG_HAS_NOT_CHANGED; diff --git a/middleware/IpcConfig/src/IpcConfig.h b/middleware/IpcConfig/src/IpcConfig.h index 73008bb..7add2c5 100644 --- a/middleware/IpcConfig/src/IpcConfig.h +++ b/middleware/IpcConfig/src/IpcConfig.h @@ -22,18 +22,27 @@ constexpr bool CONFIG_HAS_CHANGED = true; constexpr bool CONFIG_HAS_NOT_CHANGED = false; -typedef char CHAR_STRING[256]; +typedef char CHAR_STRING[64]; typedef struct Config_s { - int testNum; + bool storageLoopSwitch; + bool factoryReset; + bool formattingSDCard; + int workMode; + int continuousShot; + int burstPhotoInterval; + int videoSize; + int infraredIampPower; + int delayed; + int pirSensitivity; short testShort; + char testChar; long testLong; long long testLLong; - char testChar; - bool testBool; float testFloat; - double testDouble; - CHAR_STRING testString; + CHAR_STRING imageSize; + CHAR_STRING darkMode; + CHAR_STRING workingInterval; } Config_s; class MapInt { diff --git a/test/middleware/IpcConfig/src/IpcConfig_Test.cpp b/test/middleware/IpcConfig/src/IpcConfig_Test.cpp index eae0604..3206afb 100644 --- a/test/middleware/IpcConfig/src/IpcConfig_Test.cpp +++ b/test/middleware/IpcConfig/src/IpcConfig_Test.cpp @@ -11,10 +11,71 @@ TEST(IpcConfigTest, Demo) CreateIpcConfig(); ILogInit(LOG_INSTANCE_TYPE_END); IIpcConfig::GetInstance()->Init(); - int testNum = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::TEST_NUM); - LogInfo("Get testNum = %d\n", testNum); - const int numInt = 999; - IIpcConfig::GetInstance()->SetInt(IpcConfigKey::TEST_NUM, numInt); + + const int workMode = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_WORK_MODE); + LogInfo("Get workMode = %d\n", workMode); + const int wworkMode = WORK_MODE_PIC_VIDEO; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_WORK_MODE, wworkMode); + + const int continuousShot = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_CONTINUOUS_SHOT); + LogInfo("Get continuousShot = %d\n", continuousShot); + const int ccontinuousShot = CONTINUOUS_SHOT_TWO_PIC; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_CONTINUOUS_SHOT, ccontinuousShot); + + const int burstPhotoInterval = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_BURST_PHOTO_INTERVAL); + LogInfo("Get burstPhotoInterval = %d\n", burstPhotoInterval); + const int bburstPhotoInterval = BURST_PHOTO_INTERVAL_DEFAULT; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_BURST_PHOTO_INTERVAL, bburstPhotoInterval); + + const std::string imageSize = IIpcConfig::GetInstance()->GetString(IpcConfigKey::KEY_IMGAE_SIZE); + LogInfo("Get image_size = %s\n", imageSize.c_str()); + const std::string iimageSize = "410*410"; + IIpcConfig::GetInstance()->SetString(IpcConfigKey::KEY_IMGAE_SIZE, iimageSize); + + const int videoSize = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_VIDEO_SIZE); + LogInfo("Get video_size = %d\n", videoSize); + const int vvideoSize = VIDEO_SIZE_10; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_VIDEO_SIZE, vvideoSize); + + const int infraredIampPower = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_INFRARED_LAMP_POWER); + LogInfo("Get infrared_lamp_power = %d\n", infraredIampPower); + const int iinfraredIampPower = INFRARED_IAMP_POWER_LOW; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_INFRARED_LAMP_POWER, iinfraredIampPower); + + const int delayed = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_DELAYED); + LogInfo("Get delayed = %d\n", delayed); + const int ddelayed = DELAYED_MAX; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_DELAYED, ddelayed); + + const int pirSensitivity = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_PIR_SENSITIVITY); + LogInfo("Get pir_sensitivity = %d\n", pirSensitivity); + const int ppirSensitivity = PIR_SENSITIVITY_MAX; + IIpcConfig::GetInstance()->SetInt(IpcConfigKey::KEY_PIR_SENSITIVITY, ppirSensitivity); + + const bool storageLoopSwitch = IIpcConfig::GetInstance()->GetBool(IpcConfigKey::KEY_STORAGE_LOOP_SWITCH); + LogInfo("Get storage_loop_switch = %d\n", storageLoopSwitch); + const bool sstorageLoopSwitch = false; + IIpcConfig::GetInstance()->SetBool(IpcConfigKey::KEY_STORAGE_LOOP_SWITCH, sstorageLoopSwitch); + + const bool factoryReset = IIpcConfig::GetInstance()->GetBool(IpcConfigKey::KEY_FACTORY_RESET_FLAG); + LogInfo("Get factory_reset = %d\n", factoryReset); + const bool ffactoryReset = false; + IIpcConfig::GetInstance()->SetBool(IpcConfigKey::KEY_FACTORY_RESET_FLAG, ffactoryReset); + + const bool formattingSDCard = IIpcConfig::GetInstance()->GetBool(IpcConfigKey::KEY_FORMATTING_SD_CARD); + LogInfo("Get formatting_SD_card = %d\n", formattingSDCard); + const bool fformattingSDCard = false; + IIpcConfig::GetInstance()->SetBool(IpcConfigKey::KEY_FORMATTING_SD_CARD, fformattingSDCard); + + const std::string workInterval = IIpcConfig::GetInstance()->GetString(IpcConfigKey::KEY_WORK_INTERVAL); + LogInfo("Get work_Interval = %s\n", workInterval.c_str()); + const std::string wworkInterval = "06:00:01-06:00:00"; + IIpcConfig::GetInstance()->SetString(IpcConfigKey::KEY_WORK_INTERVAL, wworkInterval); + + const std::string drakMode = IIpcConfig::GetInstance()->GetString(IpcConfigKey::KEY_DARK_MODE); + LogInfo("Get dark_mode = %s\n", drakMode.c_str()); + const std::string ddrakMode = "18:00:00-06:00:00"; + IIpcConfig::GetInstance()->SetString(IpcConfigKey::KEY_DARK_MODE, ddrakMode); short testShort = IIpcConfig::GetInstance()->GetShort(IpcConfigKey::TEST_SHORT); LogInfo("Get test_short = %d\n", testShort); @@ -36,26 +97,11 @@ TEST(IpcConfigTest, Demo) const char numChar = 'A'; IIpcConfig::GetInstance()->SetChar(IpcConfigKey::TEST_CHAR, numChar); - bool testBool = IIpcConfig::GetInstance()->GetBool(IpcConfigKey::TEST_BOOL); - LogInfo("Get test_bool = %d\n", testBool); - const bool numBool = false; - IIpcConfig::GetInstance()->SetBool(IpcConfigKey::TEST_BOOL, numBool); - float testFloat = IIpcConfig::GetInstance()->GetFloat(IpcConfigKey::TEST_FLOAT); LogInfo("Get test_float = %lf\n", testFloat); const float numFloat = 1.123456; IIpcConfig::GetInstance()->SetFloat(IpcConfigKey::TEST_FLOAT, numFloat); - double testDouble = IIpcConfig::GetInstance()->GetDouble(IpcConfigKey::TEST_DOUBLE); - LogInfo("Get test_double = %lf\n", testDouble); - const double numDouble = 123456789.123456; - IIpcConfig::GetInstance()->SetDouble(IpcConfigKey::TEST_DOUBLE, numDouble); - - const std::string testString = IIpcConfig::GetInstance()->GetString(IpcConfigKey::TEST_STRING); - LogInfo("Get testString = %s\n", testString.c_str()); - const std::string string = "define"; - IIpcConfig::GetInstance()->SetString(IpcConfigKey::TEST_STRING, string); - IIpcConfig::GetInstance()->ConfigFileSave(); IIpcConfig::GetInstance()->UnInit(); ILogUnInit();