Merge branch 'master-develop' of gitee.com:shenzhen-jiuyilian/ipc into master-develop

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
 {

middleware/IpcConfig/src/IpcConfig.cpp

@@ -22,9 +22,64 @@ IpcConfig::IpcConfig()
 {
     mCfgChanged = CONFIG_HAS_NOT_CHANGED;
 
-    std::map<std::string, std::reference_wrapper<int>> innerMapInt;
+    std::map<std::string, std::reference_wrapper<int>> innerMapWorkMode;
-    innerMapInt.insert(std::make_pair("test_num", std::reference_wrapper<int>(mAllData.testNum)));
+    innerMapWorkMode.insert(std::make_pair("work_mode", std::reference_wrapper<int>(mAllData.workMode)));
-    mCfgMapInt.insert(std::make_pair(IpcConfigKey::TEST_NUM, innerMapInt));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_WORK_MODE, innerMapWorkMode));
+
+    std::map<std::string, std::reference_wrapper<int>> innerMapContinuousShot;
+    innerMapContinuousShot.insert(
+        std::make_pair("continuous_shot", std::reference_wrapper<int>(mAllData.continuousShot)));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_CONTINUOUS_SHOT, innerMapContinuousShot));
+
+    std::map<std::string, std::reference_wrapper<int>> innerMapBurstPhotoInterval;
+    innerMapBurstPhotoInterval.insert(
+        std::make_pair("burst_photo_interval", std::reference_wrapper<int>(mAllData.burstPhotoInterval)));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_BURST_PHOTO_INTERVAL, innerMapBurstPhotoInterval));
+
+    std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapImageSize;
+    innerMapImageSize.insert(std::make_pair("image_size", std::reference_wrapper<CHAR_STRING>(mAllData.imageSize)));
+    mCfgMapString.insert(std::make_pair(IpcConfigKey::KEY_IMGAE_SIZE, innerMapImageSize));
+
+    std::map<std::string, std::reference_wrapper<int>> innerMapVideoSize;
+    innerMapVideoSize.insert(std::make_pair("video_size", std::reference_wrapper<int>(mAllData.videoSize)));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_VIDEO_SIZE, innerMapVideoSize));
+
+    std::map<std::string, std::reference_wrapper<int>> innerMapInfraredLampPower;
+    innerMapInfraredLampPower.insert(
+        std::make_pair("infrared_lamp_power", std::reference_wrapper<int>(mAllData.infraredIampPower)));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_INFRARED_LAMP_POWER, innerMapInfraredLampPower));
+
+    std::map<std::string, std::reference_wrapper<int>> innerMapDelayed;
+    innerMapDelayed.insert(std::make_pair("delayed", std::reference_wrapper<int>(mAllData.delayed)));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_DELAYED, innerMapDelayed));
+
+    std::map<std::string, std::reference_wrapper<int>> innerMapPirSensitivity;
+    innerMapPirSensitivity.insert(
+        std::make_pair("pir_sensitivity", std::reference_wrapper<int>(mAllData.pirSensitivity)));
+    mCfgMapInt.insert(std::make_pair(IpcConfigKey::KEY_PIR_SENSITIVITY, innerMapPirSensitivity));
+
+    std::map<std::string, std::reference_wrapper<bool>> innerMapStorageLoopSwitch;
+    innerMapStorageLoopSwitch.insert(
+        std::make_pair("storage_loop_switch", std::reference_wrapper<bool>(mAllData.storageLoopSwitch)));
+    mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_STORAGE_LOOP_SWITCH, innerMapStorageLoopSwitch));
+
+    std::map<std::string, std::reference_wrapper<bool>> innerMapFactoryReset;
+    innerMapFactoryReset.insert(std::make_pair("factory_reset", std::reference_wrapper<bool>(mAllData.factoryReset)));
+    mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_FACTORY_RESET_FLAG, innerMapFactoryReset));
+
+    std::map<std::string, std::reference_wrapper<bool>> innerMapFormattingSDCard;
+    innerMapFormattingSDCard.insert(
+        std::make_pair("formatting_SD_card", std::reference_wrapper<bool>(mAllData.formattingSDCard)));
+    mCfgMapBool.insert(std::make_pair(IpcConfigKey::KEY_FORMATTING_SD_CARD, innerMapFormattingSDCard));
+
+    std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapDrakMode;
+    innerMapDrakMode.insert(std::make_pair("dark_mode", std::reference_wrapper<CHAR_STRING>(mAllData.darkMode)));
+    mCfgMapString.insert(std::make_pair(IpcConfigKey::KEY_DARK_MODE, innerMapDrakMode));
+
+    std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapWorkInterval;
+    innerMapWorkInterval.insert(
+        std::make_pair("work_interval", std::reference_wrapper<CHAR_STRING>(mAllData.workingInterval)));
+    mCfgMapString.insert(std::make_pair(IpcConfigKey::KEY_WORK_INTERVAL, innerMapWorkInterval));
 
     std::map<std::string, std::reference_wrapper<short>> innerMapShort;
     innerMapShort.insert(std::make_pair("test_short", std::reference_wrapper<short>(mAllData.testShort)));
@@ -42,21 +97,9 @@ IpcConfig::IpcConfig()
     innerMapChar.insert(std::make_pair("test_char", std::reference_wrapper<char>(mAllData.testChar)));
     mCfgMapChar.insert(std::make_pair(IpcConfigKey::TEST_CHAR, innerMapChar));
 
-    std::map<std::string, std::reference_wrapper<bool>> innerMapBool;
-    innerMapBool.insert(std::make_pair("test_bool", std::reference_wrapper<bool>(mAllData.testBool)));
-    mCfgMapBool.insert(std::make_pair(IpcConfigKey::TEST_BOOL, innerMapBool));
-
     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));
-
-    std::map<std::string, std::reference_wrapper<double>> innerMapDouble;
-    innerMapDouble.insert(std::make_pair("test_double", std::reference_wrapper<double>(mAllData.testDouble)));
-    mCfgMapDouble.insert(std::make_pair(IpcConfigKey::TEST_DOUBLE, innerMapDouble));
-
-    std::map<std::string, std::reference_wrapper<CHAR_STRING>> innerMapString;
-    innerMapString.insert(std::make_pair("test_string", std::reference_wrapper<CHAR_STRING>(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));
+    StatusCode workModeCode = ConfigGetInt(mCfg, "work_mode", &(mAllData.workMode));
-    if (StatusCodeEqual(code, "CONFIG_CODE_PARAM_NOT_EXIST")) {
+    if (StatusCodeEqual(workModeCode, "CONFIG_CODE_PARAM_NOT_EXIST")) {
-        LogWarning("test_num 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;
-        constexpr int DEFAULT_TEST_NUM = 10;
+        mAllData.workMode = WORK_MODE_PIC;
-        mAllData.testNum = DEFAULT_TEST_NUM;
+        ConfigSetInt(mCfg, "work_mode", mAllData.workMode);
-        ConfigSetInt(mCfg, "test_num", mAllData.testNum);
+    }
+
+    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;

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 imageSize;
-    CHAR_STRING testString;
+    CHAR_STRING darkMode;
+    CHAR_STRING workingInterval;
 } Config_s;
 class MapInt
 {

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 workMode = IIpcConfig::GetInstance()->GetInt(IpcConfigKey::KEY_WORK_MODE);
-    const int numInt = 999;
+    LogInfo("Get workMode = %d\n", workMode);
-    IIpcConfig::GetInstance()->SetInt(IpcConfigKey::TEST_NUM, numInt);
+    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();