Add application and middleware.

application/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_subdirectory(main)
+add_subdirectory(HuntingCamera)
+add_subdirectory(MissionManager)

application/HuntingCamera/CMakeLists.txt

@@ -0,0 +1,73 @@
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+include(${APPLICATION_SOURCE_PATH}/HuntingCamera/build/hunting_camera.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+include_directories(
+    ${HUNTTING_MAIN_INCLUDE_PATH}
+)
+
+link_directories(
+    ${LIBS_OUTPUT_PATH}
+    ${EXTERNAL_LIBS_OUTPUT_PATH}
+)
+
+aux_source_directory(. SRC_FILES)
+aux_source_directory(./src MAIN_SRC_FILE_THIS)
+
+# Mark src files for test.
+# file(GLOB_RECURSE MAIN_SRC_FILE_THIS src/*.cpp src/*.c)
+# set(MAIN_SRC_FILE     "${MAIN_SRC_FILE_THIS}" CACHE STRING INTERNAL FORCE)
+
+set(TARGET_LIB HuntingMainLib)
+add_library(${TARGET_LIB} STATIC ${MAIN_SRC_FILE_THIS})
+set(TARGET_NAME HuntingCamera_x86)
+add_executable(${TARGET_NAME} ${SRC_FILES})
+
+target_link_libraries(${TARGET_LIB} ${HUNTTING_LINK_LIB})
+target_link_libraries(${TARGET_NAME} ${TARGET_LIB})
+if(${TEST_COVERAGE} MATCHES "true")
+    target_link_libraries(${TARGET_NAME} gcov)
+endif()
+
+if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
+add_custom_target(
+    HuntingCamera_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${SRC_FILES}
+    ${MAIN_SRC_FILE_THIS}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${APPLICATION_SOURCE_PATH}/HuntingCamera
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make HuntingCamera_code_check
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    HuntingCamera_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${SRC_FILES} ${MAIN_SRC_FILE_THIS}  ${HEADER_FILES}
+    WORKING_DIRECTORY ${APPLICATION_SOURCE_PATH}/HuntingCamera
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make HuntingCamera_code_check
+    COMMAND make HuntingCamera_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()
+
+define_file_name(${TARGET_LIB})
+define_file_name(${TARGET_NAME})
+
+file(GLOB_RECURSE INSTALL_HEADER_FILES *.h)
+install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

application/HuntingCamera/build/hunting_camera.cmake

@@ -0,0 +1,16 @@
+set(HUNTTING_MAIN_INCLUDE_PATH     "${APPLICATION_SOURCE_PATH}/HuntingCamera/src")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${APPLICATION_SOURCE_PATH}/MissionManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/StateMachine/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/McuManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/AppManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/MediaManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/FilesManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/StorageManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/HuntingUpgrade/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/IpcConfig/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/StatusCode/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/Log/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${HAL_SOURCE_PATH}/include")
+
+set(HUNTTING_LINK_LIB McuManager MissionManager StateMachine AppManager FilesManager StorageManager HuntingUpgrade IpcConfig DeviceManager StatusCode Log Hal pthread dl)

application/HuntingCamera/main.cpp

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "ILog.h"
+#include "MainThread.h"
+#include <thread>
+int main(int argc, char *argv[])
+{
+    MainThread::GetInstance()->Init();
+    MainThread::GetInstance()->Runing();
+    MainThread::GetInstance()->UnInit();
+    return 0;
+}

application/HuntingCamera/src/MainThread.cpp

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MainThread.h"
+#include "IAppManager.h"
+#include "IDeviceManager.h"
+#include "IFilesManager.h"
+#include "IHalCpp.h"
+#include "IHuntingUpgrade.h"
+#include "IIpcConfig.h"
+#include "ILog.h"
+#include "IMcuManager.h"
+#include "IMediaManager.h"
+#include "IMissionManager.h"
+#include "IStateMachine.h"
+#include "IStorageManager.h"
+#include <signal.h>
+#include <thread>
+static void sigHandler(int signo)
+{
+    LogInfo("Stop main application.\n");
+    MainThread::GetInstance()->Exit();
+}
+void InitSignalHandle(void)
+{
+    signal(SIGINT, sigHandler);
+    signal(SIGTERM, sigHandler);
+    signal(SIGKILL, sigHandler);
+    signal(SIGPIPE, SIG_IGN);
+}
+MainThread::MainThread()
+{
+    mMainThreadRuning = false;
+}
+std::shared_ptr<MainThread> &MainThread::GetInstance(std::shared_ptr<MainThread> *impl)
+{
+    static auto instance = std::make_shared<MainThread>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+StatusCode MainThread::Init(void)
+{
+    InitSignalHandle();
+    CreateLogModule();
+    ILogInit(LOG_EASYLOGGING);
+    CustomizationInit();
+    mMainThreadRuning = true;
+    CreateAllModules();
+    IHalCpp::GetInstance()->Init();
+    IDeviceManager::GetInstance()->Init();
+    IMcuManager::GetInstance()->Init();
+    IStorageManager::GetInstance()->Init();
+    IIpcConfig::GetInstance()->Init();
+    IMediaManager::GetInstance()->Init();
+    IMissionManager::GetInstance()->Init();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode MainThread::UnInit(void)
+{
+    IMissionManager::GetInstance()->UnInit();
+    IMediaManager::GetInstance()->UnInit();
+    IIpcConfig::GetInstance()->UnInit();
+    IStorageManager::GetInstance()->UnInit();
+    IMcuManager::GetInstance()->UnInit();
+    IDeviceManager::GetInstance()->UnInit();
+    IHalCpp::GetInstance()->UnInit();
+    DestoryAllModules();
+    ILogUnInit();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode MainThread::CreateAllModules(void)
+{
+    CreateHalCppModule();
+    CreateMcuManager();
+    CreateStorageManagerModule();
+    CreateFilesManagerModule();
+    CreateMissionManagerModule();
+    CreateStateMachine();
+    CreateAppManagerModule();
+    CreateMediaManagerModule();
+    CreateHuntingUpgradeModule();
+    CreateIpcConfigModule();
+    CreateDeviceManagerModule();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void MainThread::DestoryAllModules(void)
+{
+    DestroyHuntingUpgradeModule();
+    DestroyMediaManagerModule();
+    DestroyAppManagerModule();
+    DestroyStateMachine();
+    DestroyMissionManagerModule();
+    DestroyFilesManagerModule();
+    DestroyStorageManagerModule();
+    DestroyMcuManager();
+    DestroyHalCppModule();
+    DestroyIpcConfigModule();
+    DestroyDeviceManagerModule();
+}
+void MainThread::ResetAllPtrMaker(void)
+{
+}
+void MainThread::Runing(void)
+{
+    while (mMainThreadRuning) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+}
+extern bool CreateProtocolHandleImpl(void);
+void MainThread::CustomizationInit(void)
+{
+    CreateProtocolHandleImpl();
+}

application/HuntingCamera/src/MainThread.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MAIN_THREAD_H
+#define MAIN_THREAD_H
+#include "StatusCode.h"
+#include <memory>
+class MainThread
+{
+public:
+    MainThread();
+    virtual ~MainThread() = default;
+    static std::shared_ptr<MainThread> &GetInstance(std::shared_ptr<MainThread> *impl = nullptr);
+    virtual StatusCode Init(void);
+    virtual StatusCode UnInit(void);
+    void Runing(void);
+    void Exit(void)
+    {
+        mMainThreadRuning = false;
+    }
+    virtual void CustomizationInit(void);
+
+private:
+    StatusCode CreateAllModules(void);
+    void DestoryAllModules(void);
+    void ResetAllPtrMaker(void);
+
+private:
+    bool mMainThreadRuning;
+};
+#endif // !MAIN_THREAD_H

application/MissionManager/CMakeLists.txt

@@ -0,0 +1,73 @@
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+# include(${UTILS_SOURCE_PATH}/WebServer/build/webserver.cmake)
+include(${MIDDLEWARE_SOURCE_PATH}/AppManager/build/app_manager.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+include_directories(
+    ./src
+    ./include
+    ${UTILS_SOURCE_PATH}/StatusCode/include
+    ${UTILS_SOURCE_PATH}/Log/include
+    ${UTILS_SOURCE_PATH}/KeyControl/include
+    ${UTILS_SOURCE_PATH}/LedControl/include
+    ${MIDDLEWARE_SOURCE_PATH}/StateMachine/include
+    ${MIDDLEWARE_SOURCE_PATH}/AppManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/MediaManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/FilesManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/StorageManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/McuManager/include
+    ${MIDDLEWARE_SOURCE_PATH}/McuAskBase/include
+    ${MIDDLEWARE_SOURCE_PATH}/HuntingUpgrade/include
+    ${MIDDLEWARE_SOURCE_PATH}/DeviceManager/include
+)
+#do not rely on any other library
+#link_directories(
+#)
+
+aux_source_directory(./src SRC_FILES)
+
+set(TARGET_NAME MissionManager)
+add_library(${TARGET_NAME} STATIC ${SRC_FILES})
+
+target_link_libraries(${TARGET_NAME} McuAskBase StateMachine MediaManager StorageManager DeviceManager HuntingUpgrade KeyControl LedControl StatusCode Log)
+
+if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
+add_custom_target(
+    MissionManager_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${SRC_FILES}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${APPLICATION_SOURCE_PATH}/MissionManager
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make MissionManager_code_check
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    MissionManager_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${SRC_FILES}  ${HEADER_FILES}
+    WORKING_DIRECTORY ${APPLICATION_SOURCE_PATH}/MissionManager
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make MissionManager_code_check
+    COMMAND make MissionManager_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()
+
+define_file_name(${TARGET_NAME})
+
+file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
+install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

application/MissionManager/README.md

@@ -0,0 +1,82 @@
+
+# 1. 相机任务管理
+
+  相机主业务逻辑使用状态机机制进行管理。
+
+## 1.1. 任务状态
+
+  任务状态是指相机启动需要执行的任务，可能是拍照 / 视频，可能是其它任务。
+
+**例如：**
+1. 移动物体侦测启动；
+2. 定时启动拍照 / 录像；
+3. 测试启动；
+
+## 1.2. 状态机设计
+
+### 1.2.1. 状态树设计图
+
+```mermaid
+stateDiagram-v2
+[*] --> TopState
+TopState --> PowerOff
+TopState --> MSDCState
+TopState --> DeviceAbnormal
+TopState --> MissionState
+MissionState --> 空闲
+MissionState --> 存储管理
+存储管理 --> EMMC
+存储管理 --> SD卡
+MissionState --> 媒体管理
+SD卡 --> 插卡
+SD卡 --> 拔卡
+SD卡 --> 卡异常
+MissionState --> 网络管理
+网络管理 --> 联网
+联网 --> 上传文件
+网络管理 --> 未联网
+MissionState --> 直播
+MissionState --> 4G管理
+4G管理 --> Sim卡初始化
+4G管理 --> 注网状态
+MissionState --> Upgrade
+```
+
+1. 任意状态处理命令时，不能阻塞，否则整个应用将会瘫痪无法响应任意的命令；
+2. MissionState: 任务状态，在此状态下，由任务状态处理各种逻辑命令，根据逻辑命令定义，切换到相应的状态再处理数据，处理完数据会停留在当前状态，等待新的命令；
+
+## 1.3. 任务状态获取启动
+
+  应用程序运行后，首先需要知道主控是由于何种任务被唤醒，然后根据任务来执行相应的功能代码；
+
+**时序图**
+
+```mermaid
+sequenceDiagram
+participant MCU
+participant 大核
+MCU ->> MCU:待机
+opt MCU上电
+    MCU ->> 大核:上电
+    activate 大核
+        大核 ->> 大核:系统初始化
+        大核 ->> 大核:启动脚本拉起APP
+        大核 ->> +MCU:读取启动任务
+        MCU -->> -大核:return
+        alt PIR触发
+            大核 ->> 大核:APP初始化
+            大核 ->> 大核:抓拍并保存
+        else 定时
+            大核 ->> 大核:APP初始化
+            大核 ->> 大核:抓拍并保存
+        else TEST
+            大核 ->> 大核:APP初始化
+            大核 ->> 大核:待机
+        end
+    deactivate 大核
+end
+```
+
+## 1.4. MCU监视器
+
+  MCU监视器必须由其中一个状态继承，只有状态机运行之后才能处理串口命令。

application/MissionManager/include/IMissionManager.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef I_MISSION_MANAGER
+#define I_MISSION_MANAGER
+#include "StatusCode.h"
+#include <functional>
+#include <memory>
+bool CreateMissionManagerModule(void);
+bool DestroyMissionManagerModule(void);
+enum class MissionEvent
+{
+    TEST = 0,
+    END
+};
+class VMissionData
+{
+public:
+    VMissionData(const MissionEvent &event) : mEvent(event)
+    {
+        mRetryTimes = 0;
+        mDelayTimeMs = 0;
+    }
+    virtual ~VMissionData() = default;
+    const MissionEvent mEvent;
+    int mRetryTimes;
+    unsigned int mDelayTimeMs;
+    std::function<void(bool, std::shared_ptr<VMissionData>)> mMissionFinshed;
+};
+template <typename T>
+class VMissionDataV2 : public VMissionData
+{
+
+public:
+    VMissionDataV2(const MissionEvent &event, T value) : VMissionData(event), mData(value)
+    {
+    }
+    virtual ~VMissionDataV2() = default;
+
+public:
+    T mData;
+};
+class IMissionManager
+{
+public:
+    IMissionManager() = default;
+    virtual ~IMissionManager() = default;
+    static std::shared_ptr<IMissionManager> &GetInstance(std::shared_ptr<IMissionManager> *impl = nullptr);
+    virtual const StatusCode Init(void);
+    virtual const StatusCode UnInit(void);
+};
+#endif

application/MissionManager/src/AppMonitor.cpp

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "AppMonitor.h"
+#include "ILog.h"
+#include <vector>
+StatusCode AppMonitor::GetProductInfo(AppGetProductInfo &param)
+{
+    LogInfo("AppMonitor::GetProductInfo.\n");
+    param.mModel = "test";
+    param.mCompany = "test";
+    param.mSoc = "test";
+    param.mSp = "test";
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetDeviceAttr(AppGetDeviceAttr &param)
+{
+    LogInfo("AppMonitor::GetDeviceAttr.\n");
+    param.mUUID = "test";
+    param.mSoftVersion = "test";
+    param.mOtaVersion = "test";
+    param.mHardwareVersion = "test";
+    param.mSSID = "test";
+    param.mBSSID = "test";
+    param.mCameraNumber = "test";
+    param.mCurrentCameraID = "test";
+    param.mWifiReboot = "test";
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetMediaInfo(AppGetMediaInfo &param)
+{
+    LogInfo("AppMonitor::GetMediaInfo.\n");
+    param.mRtspUrl = "rtsp://192.168.169.1/live/0";
+    param.mTransport = "tcp";
+    param.mPort = APP_MANAGER_TCP_SERVER_PORT;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetSdCardInfo(AppGetSdCardInfo &param)
+{
+    LogInfo("AppMonitor::GetSdCardInfo.\n");
+    SdCardInfo info;
+    IStorageManager::GetInstance()->GetSdCardInfo(info);
+    param.mStatus = SdCardStatusConvert(info.mEvent);
+    param.mFree = info.mFreeSizeMB;
+    param.mTotal = info.mTotalSizeMB;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
+{
+    LogInfo("AppMonitor::GetBatteryInfo.\n");
+    param.mCapacity = 0;
+    param.mChargeStatus = ChargeStatus::CHARGING;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetParamValue(AppParamValue &param)
+{
+    param.mMicStatus = SwitchStatus::ON;
+    param.mRec = SwitchStatus::OFF;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetCapability(AppGetCapability &param)
+{
+    param.mPlaybackType = PlaybackType::DOWNLOAD_PLAYBACK;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetLockVideoStatus(LockVideoStatus &param)
+{
+    param = LockVideoStatus::LOCK;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetStorageInfo(std::vector<AppGetStorageInfo> &param)
+{
+    AppGetStorageInfo info;
+    SdCardInfo sdInfo;
+    IStorageManager::GetInstance()->GetSdCardInfo(sdInfo);
+    info.mIndex = 0;
+    info.mName = "TF card 1";
+    info.mType = StorageType::SD_CARD_1;
+    info.mFree = sdInfo.mFreeSizeMB;
+    info.mTotal = sdInfo.mTotalSizeMB;
+    param.push_back(info);
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
+{
+    if (StorageFileEvent::LOOP == fileInfo.mEvent) {
+        AppGetFileList file;
+        file.mCreateTime_s = 123456789;
+        file.mDuration = 182;
+        file.mName = "/DCIM/2024/01/15/20240115140207-20240115140509.mp4";
+        file.mSize = 1024 * 182;
+        file.mType = StorageFileType::VIDEO;
+        param.push_back(file);
+        AppGetFileList file2;
+        file2.mCreateTime_s = 123456789;
+        file2.mDuration = 0;
+        file2.mName = "/34a396526922a33e97906920dbfef2a5.jpg";
+        file2.mSize = 1024;
+        file2.mType = StorageFileType::PICTURE;
+        param.push_back(file2);
+    }
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::SetDateTime(const AppSetDateTime &param)
+{
+    //
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::SetTimeZone(const unsigned int &zone)
+{
+    //
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::SetParamValue(const AppSetParamValue &param)
+{
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::EnterRecorder(void)
+{
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::AppPlayback(const PlayBackEvent &event)
+{
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::UploadFile(AppUploadFile &param)
+{
+    //
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppMonitor::GetThumbnail(AppGetThumbnail &param)
+{
+    param.mThumbnail = "./34a396526922a33e97906920dbfef2a5.jpg";
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+SdCardStatus AppMonitor::SdCardStatusConvert(const StorageEvent &event)
+{
+    switch (event) {
+    case StorageEvent::SD_CARD_INSERT:
+        return SdCardStatus::NORMAL;
+    case StorageEvent::SD_CARD_REMOVE:
+        return SdCardStatus::NOT_INSERTED;
+    case StorageEvent::SD_ABNORMAL:
+        return SdCardStatus::NOT_INSERTED;
+    default:
+        return SdCardStatus::END;
+    }
+}

application/MissionManager/src/AppMonitor.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef APP_MONITOR_H
+#define APP_MONITOR_H
+#include "IAppManager.h"
+#include "IStorageManager.h"
+class AppMonitor : public VAppMonitor
+{
+public:
+    AppMonitor() = default;
+    virtual ~AppMonitor() = default;
+    StatusCode GetProductInfo(AppGetProductInfo &param) override;
+    StatusCode GetDeviceAttr(AppGetDeviceAttr &param) override;
+    StatusCode GetMediaInfo(AppGetMediaInfo &param) override;
+    StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
+    StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
+    StatusCode GetParamValue(AppParamValue &param) override;
+    StatusCode GetCapability(AppGetCapability &param) override;
+    StatusCode GetLockVideoStatus(LockVideoStatus &param) override;
+    StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param) override;
+    StatusCode GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param) override;
+    StatusCode SetDateTime(const AppSetDateTime &param) override;
+    StatusCode SetTimeZone(const unsigned int &zone) override;
+    StatusCode SetParamValue(const AppSetParamValue &param) override;
+    StatusCode EnterRecorder(void) override;
+    StatusCode AppPlayback(const PlayBackEvent &event) override;
+    StatusCode UploadFile(AppUploadFile &param) override;
+    StatusCode GetThumbnail(AppGetThumbnail &param) override;
+
+private:
+    SdCardStatus SdCardStatusConvert(const StorageEvent &event);
+};
+#endif

application/MissionManager/src/DataProcessing.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "DataProcessing.h"
+#include "ILog.h"
+const bool NOT_EXECUTED = false;
+const bool EXECUTED = true;
+key_event_data::key_event_data(const std::string &keyName, const KeyEvent &keyEvent, const unsigned int &holdTime)
+    : mKeyName(keyName), mKeyEvent(keyEvent), mHoldTime(holdTime)
+{
+}
+MissionData::MissionData(const std::shared_ptr<VMissionData> &data) : mMissionData(data)
+{
+}
+MissionMessage::MissionMessage(const std::shared_ptr<VMissionData> &message) : mMissionData(message)
+{
+}
+DataProcessing::DataProcessing()
+{
+    mEventHandle[InternalStateEvent::KEY_EVENT_HANDLE] = std::bind(&DataProcessing::KeyEventHandle, this, _1);
+}
+bool DataProcessing::EventHandle(VStateMachineData *msg)
+{
+    if (nullptr == msg) {
+        LogError("nullptr pointer.\n");
+        return NOT_EXECUTED;
+    }
+    std::map<InternalStateEvent, DataProcessingFunc>::iterator iter;
+    std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
+    InternalStateEvent event = static_cast<InternalStateEvent>(message->mMissionData->mEvent);
+    iter = mEventHandle.find(event);
+    if (iter != mEventHandle.end()) {
+        return mEventHandle[event](msg);
+    }
+    return NOT_EXECUTED;
+}
+bool DataProcessing::KeyEventHandle(VStateMachineData *msg)
+{
+    if (nullptr == msg) {
+        LogError("nullptr pointer.\n");
+        return NOT_EXECUTED;
+    }
+    std::map<std::string, KeyHandleFunc>::iterator iter;
+    std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
+    std::shared_ptr<VMissionDataV2<KeyEventData>> data =
+        std::dynamic_pointer_cast<VMissionDataV2<KeyEventData>>(message->mMissionData);
+    if (!data) {
+        LogError("nullptr pointer.\n");
+        return NOT_EXECUTED;
+    }
+    iter = mKeyClickHandle.find(data->mData.mKeyName);
+    if (iter != mKeyClickHandle.end() && KeyEvent::SHORT_CLICK == data->mData.mKeyEvent) {
+        return mKeyClickHandle[data->mData.mKeyName](data->mData);
+    }
+    iter = mKeyHoldDownHandle.find(data->mData.mKeyName);
+    if (iter != mKeyHoldDownHandle.end() && KeyEvent::HOLD_DOWN == data->mData.mKeyEvent) {
+        return mKeyHoldDownHandle[data->mData.mKeyName](data->mData);
+    }
+    iter = mKeyHoldUpHandle.find(data->mData.mKeyName);
+    if (iter != mKeyHoldUpHandle.end() && KeyEvent::HOLD_UP == data->mData.mKeyEvent) {
+        return mKeyHoldUpHandle[data->mData.mKeyName](data->mData);
+    }
+    return NOT_EXECUTED;
+}

application/MissionManager/src/DataProcessing.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DATA_PROCESSING_H
+#define DATA_PROCESSING_H
+#include "IMissionManager.h"
+#include "IStateMachine.h"
+#include "KeyControl.h"
+#include <functional>
+#include <map>
+using std::placeholders::_1;
+using DataProcessingFunc = std::function<bool(VStateMachineData *)>;
+enum class InternalStateEvent
+{
+    STORAGE_HANDLE_STATE_INIT = static_cast<int>(MissionEvent::END),
+    SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED,
+    ANY_STATE_SD_STATUS_PERORIED,
+    CHECK_UPGRADE_FILE,
+    MEDIA_REPORT_EVENT,
+    KEY_EVENT_HANDLE,
+    RESET_KEY_MEDIA_TASK,
+    MEDIA_HANDLE_STATE_TASK_TIME_OUT,
+    END
+};
+typedef struct key_event_data
+{
+    key_event_data(const std::string &keyName, const KeyEvent &keyEvent, const unsigned int &holdTime);
+    const std::string mKeyName;
+    const KeyEvent mKeyEvent;
+    const unsigned int mHoldTime;
+} KeyEventData;
+using KeyHandleFunc = std::function<bool(const KeyEventData &)>;
+class MissionData : public VStateMachineData
+{
+public:
+    MissionData(const std::shared_ptr<VMissionData> &data);
+    virtual ~MissionData() = default;
+    const std::shared_ptr<VMissionData> mMissionData;
+};
+/**
+ * @brief
+ * MissionMessage abstracts user data into state machine data, enabling the transfer of arbitrary data within the state
+ * machine.
+ */
+class MissionMessage : public VStateMessage
+{
+public:
+    MissionMessage(const std::shared_ptr<VMissionData> &message);
+    virtual ~MissionMessage() = default;
+    const std::shared_ptr<VMissionData> mMissionData; // The message from users of state manager module.
+};
+class DataProcessing
+{
+public:
+    DataProcessing();
+    virtual ~DataProcessing() = default;
+    bool EventHandle(VStateMachineData *msg);
+    virtual bool KeyEventHandle(VStateMachineData *msg);
+
+protected:
+    std::map<InternalStateEvent, DataProcessingFunc> mEventHandle;
+    std::map<std::string, DataProcessingFunc> mKeyEventHandle;
+    std::map<std::string, KeyHandleFunc> mKeyClickHandle;
+    std::map<std::string, KeyHandleFunc> mKeyHoldDownHandle;
+    std::map<std::string, KeyHandleFunc> mKeyHoldUpHandle;
+};
+#endif

application/MissionManager/src/IMissionManager.cpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "IMissionManager.h"
+#include "ILog.h"
+std::shared_ptr<IMissionManager> &IMissionManager::GetInstance(std::shared_ptr<IMissionManager> *impl)
+{
+    static auto instance = std::make_shared<IMissionManager>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+const StatusCode IMissionManager::Init(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+const StatusCode IMissionManager::UnInit(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}

application/MissionManager/src/IdleState.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "IdleState.h"
+#include "IFilesManager.h"
+#include "ILog.h"
+#include "IMediaManager.h"
+#include "MissionStateMachine.h"
+IdleState::IdleState() : State("IdleState")
+{
+    // mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&IdleState::MediaReportHandle, this, _1);
+    // mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
+    //     std::bind(&IdleState::SdCardEventHandle, this, _1);
+}
+void IdleState::GoInState()
+{
+    LogInfo(" ========== IdleState::GoInState.\n");
+}
+void IdleState::GoOutState()
+{
+    LogInfo(" ========== IdleState::GoOutState.\n");
+}
+bool IdleState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}

application/MissionManager/src/IdleState.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef IDLE_STATE_H
+#define IDLE_STATE_H
+#include "DataProcessing.h"
+#include "IStateMachine.h"
+class IdleState : public State, public DataProcessing, public std::enable_shared_from_this<IdleState>
+{
+public:
+    IdleState();
+    virtual ~IdleState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+
+private:
+};
+#endif

application/MissionManager/src/LedsHandle.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "LedsHandle.h"
+#include "ILog.h"
+void LedsHandle::ControlDeviceStatusLed(const DeviceStatus &status, const long int &keepAliveTime,
+                                        const unsigned int &blinkPeriod)
+{
+    switch (status) {
+    case DeviceStatus::NORMAL:
+        mDeviceStatus = SetLedState::ControlLed("device_status", LedState::GREEN, keepAliveTime, blinkPeriod);
+        break;
+
+    default:
+        LogWarning("unknow device status.\n");
+        break;
+    }
+}
+void inline LedsHandle::DeleteDeviceStatusLed(void)
+{
+    mDeviceStatus->DeleteState();
+}
+void LedsHandle::DeleteAllLeds(void)
+{
+    DeleteDeviceStatusLed();
+}

application/MissionManager/src/LedsHandle.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef LEDS_HANDLE_H
+#define LEDS_HANDLE_H
+#include "SetLedState.h"
+enum class DeviceStatus
+{
+    NORMAL = 0,
+    TAKING_PICTURE_OR_VIDEO,
+    END
+};
+class LedsHandle
+{
+public:
+    LedsHandle() = default;
+    virtual ~LedsHandle() = default;
+
+protected:
+    /**
+     * @brief This function is designed as a virtual function so that when the board uses different LED circuits, this
+     * function can be overloaded to achieve polymorphic control of the light.
+     * @param status
+     * @param keepAliveTime
+     * @param blinkPeriod
+     */
+    virtual void ControlDeviceStatusLed(const DeviceStatus &status, const long int &keepAliveTime = KEEP_ALIVE_FOREVER,
+                                        const unsigned int &blinkPeriod = LED_NOT_BLINK);
+    void DeleteDeviceStatusLed(void);
+    void DeleteAllLeds(void);
+
+private:
+    std::shared_ptr<SetLedState> mDeviceStatus;
+};
+#endif

application/MissionManager/src/McuMonitor.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "McuMonitor.h"
+#include "ILog.h"
+#include "IMcuManager.h"
+void McuMonitor::Init(std::shared_ptr<VMcuMonitor> &monitor)
+{
+    IMcuManager::GetInstance()->SetMcuMonitor(monitor);
+}
+void McuMonitor::UnInit(void)
+{
+}
+void McuMonitor::RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission)
+{
+}
+void McuMonitor::RecvMcuHeartBeatEvent(std::shared_ptr<VMcuRecv> &recv)
+{
+}
+void McuMonitor::RecvGetIntervalStartEvent(std::shared_ptr<VMcuRecv> &recv)
+{
+    LogInfo("RecvGetIntervalStartEvent\n");
+    std::shared_ptr<McuRecv<McuGetIntervalStart>> recvData =
+        std::dynamic_pointer_cast<McuRecv<McuGetIntervalStart>>(recv);
+    if (recvData) {
+        recvData->mDataRecvReply.mHour = 10;
+        recvData->mDataRecvReply.mMin = 10;
+        recvData->mDataRecvReply.mSecond = 10;
+        recv->ReplyFinished(true);
+    }
+    recv->ReplyFinished(false);
+}
+void McuMonitor::RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv)
+{
+    LogInfo("RecvGetDateTime\n");
+    std::shared_ptr<McuRecv<McuReplyDateTime>> recvData = std::dynamic_pointer_cast<McuRecv<McuReplyDateTime>>(recv);
+    if (recvData) {
+        recvData->mDataRecvReply.mYear = 2024;
+        recvData->mDataRecvReply.mMon = 10;
+        recvData->mDataRecvReply.mDay = 10;
+        recvData->mDataRecvReply.mHour = 10;
+        recvData->mDataRecvReply.mMin = 10;
+        recvData->mDataRecvReply.mSecond = 10;
+        recv->ReplyFinished(true);
+    }
+    recv->ReplyFinished(false);
+}
+void McuMonitor::RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv)
+{
+    LogInfo("RecvGetPirSensitivity\n");
+    std::shared_ptr<McuRecv<McuGetPirSensitivity>> recvData =
+        std::dynamic_pointer_cast<McuRecv<McuGetPirSensitivity>>(recv);
+    if (recvData) {
+        recvData->mDataRecvReply.mSensitivity = 9;
+        recv->ReplyFinished(true);
+    }
+    recv->ReplyFinished(false);
+}

application/MissionManager/src/McuMonitor.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MCU_MONITOR_H
+#define MCU_MONITOR_H
+#include "IMcuManager.h"
+class McuMonitor : public VMcuMonitor
+{
+public:
+    McuMonitor() = default;
+    virtual ~McuMonitor() = default;
+    void Init(std::shared_ptr<VMcuMonitor> &monitor);
+    void UnInit(void);
+    void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override;
+    void RecvMcuHeartBeatEvent(std::shared_ptr<VMcuRecv> &recv) override;
+    void RecvGetIntervalStartEvent(std::shared_ptr<VMcuRecv> &recv) override;
+    void RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv) override;
+    void RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv) override;
+};
+#endif

application/MissionManager/src/MediaHandleState.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MediaHandleState.h"
+#include "IFilesManager.h"
+#include "ILog.h"
+#include "IMediaManager.h"
+#include "MissionStateMachine.h"
+MediaHandleState::MediaHandleState() : State("MediaHandleState")
+{
+    mEventHandle[InternalStateEvent::RESET_KEY_MEDIA_TASK] =
+        std::bind(&MediaHandleState::ResetKeyMediaTaskHandle, this, _1);
+}
+void MediaHandleState::GoInState()
+{
+    LogInfo(" ========== MediaHandleState::GoInState.\n");
+    if (!mMediaHandle) {
+        MediaTaskHandle::Init();
+    }
+}
+void MediaHandleState::GoOutState()
+{
+    LogInfo(" ========== MediaHandleState::GoOutState.\n");
+}
+bool MediaHandleState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}
+void MediaHandleState::TaskResponse(const std::vector<MediaTaskResponse> &response)
+{
+}
+bool MediaHandleState::ResetKeyMediaTaskHandle(VStateMachineData *msg)
+{
+    MakeSingleTask(InternalStateEvent::RESET_KEY_MEDIA_TASK, shared_from_this());
+    return EXECUTED;
+}

application/MissionManager/src/MediaHandleState.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MEDIA_HANDLE_STATE_H
+#define MEDIA_HANDLE_STATE_H
+#include "DataProcessing.h"
+#include "IStateMachine.h"
+#include "MediaTaskHandle.h"
+class MediaHandleState : public State,
+                         public DataProcessing,
+                         public MediaTaskHandle,
+                         public VMediaTaskIniator,
+                         public std::enable_shared_from_this<MediaHandleState>
+{
+public:
+    MediaHandleState();
+    virtual ~MediaHandleState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+
+private:
+    void TaskResponse(const std::vector<MediaTaskResponse> &response) override;
+    bool ResetKeyMediaTaskHandle(VStateMachineData *msg);
+};
+#endif

application/MissionManager/src/MediaTask.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MediaTask.h"
+MediaTask::MediaTask(const MediaTaskType &type, const InternalStateEvent &bindEvent,
+                     const std::weak_ptr<VMediaTaskIniator> &iniator)
+    : mType(type), mBindEvent(bindEvent), mIniator(iniator)
+{
+    mResponseData.reset();
+}
+unsigned int MediaTask::GetTaskTimeOutMs(void)
+{
+    return MEDIA_TASK_TIMEOUT_MS;
+}

application/MissionManager/src/MediaTask.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MEDIA_TASK_H
+#define MEDIA_TASK_H
+#include "DataProcessing.h"
+#include "IMediaManager.h"
+constexpr unsigned int MEDIA_TASK_TIMEOUT_MS = 1000 * 60;
+class VMediaTaskIniator
+{
+public:
+    VMediaTaskIniator() = default;
+    virtual ~VMediaTaskIniator() = default;
+    virtual void TaskResponse(const std::vector<MediaTaskResponse> &response) = 0;
+};
+class MediaTask : public VMediaTask
+{
+public:
+    MediaTask(const MediaTaskType &type, const InternalStateEvent &bindEvent,
+              const std::weak_ptr<VMediaTaskIniator> &iniator);
+    virtual ~MediaTask() = default;
+    virtual unsigned int GetTaskTimeOutMs(void);
+
+private:
+    const MediaTaskType mType;
+    const InternalStateEvent mBindEvent;
+    const std::weak_ptr<VMediaTaskIniator> mIniator;
+    bool mFinished = false;
+    std::shared_ptr<MediaTaskResponse> mResponseData;
+};
+#endif

application/MissionManager/src/MediaTaskHandle.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MediaTaskHandle.h"
+#include "ILog.h"
+#include "MissionStateMachine.h"
+MediaTaskHandle::MediaTaskHandle()
+{
+    mMediaHandle.reset();
+    // mMediaHandle = std::make_shared<VMediaHandle>();
+}
+void MediaTaskHandle::Init(void)
+{
+    IMediaManager::GetInstance()->GetMediaChannel(MediaChannel::MEDIA_1, mMediaHandle);
+}
+void MediaTaskHandle::UnInit(void)
+{
+    mMediaHandle->ClearTask();
+    mMediaHandle.reset();
+}
+void MediaTaskHandle::MakeSingleTask(const InternalStateEvent &bindEvent,
+                                     const std::shared_ptr<VMediaTaskIniator> &iniator)
+{
+    std::shared_ptr<VMediaTask> task = std::make_shared<MediaTask>(MediaTaskType::END, bindEvent, iniator);
+    if (!mMediaHandle) {
+        LogError("MediaHandle is null");
+        return;
+    }
+    auto code = mMediaHandle->ExecuteTask(task);
+    if (IsCodeOK(code)) {
+        mRuningTask = task;
+        long long timeOut = std::dynamic_pointer_cast<MediaTask>(task)->GetTaskTimeOutMs();
+        std::shared_ptr<VMissionData> message = std::make_shared<VMissionData>(
+            static_cast<MissionEvent>(InternalStateEvent::MEDIA_HANDLE_STATE_TASK_TIME_OUT));
+        MissionStateMachine::GetInstance()->MessageExecutedLater(message, timeOut);
+    }
+    // else if () {
+    //     mMediaHandle->StopTask();
+    // }
+}

application/MissionManager/src/MediaTaskHandle.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MEDIA_TASK_HANDLE_H
+#define MEDIA_TASK_HANDLE_H
+#include "DataProcessing.h"
+#include "IMediaManager.h"
+#include "MediaTask.h"
+class MediaTaskHandle
+{
+public:
+    MediaTaskHandle();
+    virtual ~MediaTaskHandle() = default;
+    void Init(void);
+    void UnInit(void);
+    void MakeSingleTask(const InternalStateEvent &bindEvent, const std::shared_ptr<VMediaTaskIniator> &iniator);
+
+protected:
+    std::shared_ptr<VMediaHandle> mMediaHandle;
+
+private:
+    std::shared_ptr<VMediaTask> mRuningTask;
+};
+#endif

application/MissionManager/src/MissionManager.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MissionManager.h"
+#include "IAppManager.h"
+#include "MissionStateMachine.h"
+const StatusCode MissionManager::Init(void)
+{
+    MissionStateMachine::GetInstance()->Init();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode MissionManager::UnInit(void)
+{
+    MissionStateMachine::GetInstance()->UnInit();
+    IAppManager::GetInstance()->UnInit();
+    return CreateStatusCode(STATUS_CODE_OK);
+}

application/MissionManager/src/MissionManager.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MISSION_MANAGER_H
+#define MISSION_MANAGER_H
+#include "IMissionManager.h"
+class MissionManager : public IMissionManager
+{
+public:
+    MissionManager() = default;
+    virtual ~MissionManager() = default;
+    const StatusCode Init(void) override;
+    const StatusCode UnInit(void) override;
+};
+#endif

application/MissionManager/src/MissionManagerMakePtr.cpp

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MissionManagerMakePtr.h"
+#include "ILog.h"
+#include "IdleState.h"
+#include "MediaHandleState.h"
+#include "MissionManager.h"
+#include "OnMissionState.h"
+#include "PirTriggeredMissionState.h"
+#include "SdCardHandleState.h"
+#include "StorageHandleState.h"
+#include "TestMissionState.h"
+#include "TopState.h"
+#include "UpgradeState.h"
+bool CreateMissionManagerModule(void)
+{
+    auto instance = std::make_shared<IMissionManager>();
+    StatusCode code = MissionManagerMakePtr::GetInstance()->CreateMissionManagerInstance(instance);
+    if (IsCodeOK(code)) {
+        LogInfo("CreateMcuManager is ok.\n");
+        IMissionManager::GetInstance(&instance);
+        return true;
+    }
+    return false;
+}
+bool DestroyMissionManagerModule(void)
+{
+    auto instance = std::make_shared<IMissionManager>();
+    IMissionManager::GetInstance(&instance);
+    return true;
+}
+std::shared_ptr<MissionManagerMakePtr> &MissionManagerMakePtr::GetInstance(std::shared_ptr<MissionManagerMakePtr> *impl)
+{
+    static auto instance = std::make_shared<MissionManagerMakePtr>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+const StatusCode MissionManagerMakePtr::CreateMissionManagerInstance(std::shared_ptr<IMissionManager> &instance)
+{
+    instance = std::make_shared<MissionManager>();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateTopState(void)
+{
+    std::shared_ptr<State> state = std::make_shared<TopState>();
+    return state;
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateMissionState(const IpcMission &mission)
+{
+    LogInfo("MissionManagerMakePtr::CreateMissionState\n");
+    std::shared_ptr<State> state;
+    switch (mission) {
+    case IpcMission::PIR_TRIGGERED:
+        LogInfo("Create PirTriggeredMissionState.\n");
+        state = std::make_shared<PirTriggeredMissionState>();
+        break;
+    case IpcMission::TEST:
+        LogInfo("Create TestMissionState.\n");
+        state = std::make_shared<TestMissionState>();
+        break;
+    case IpcMission::ON:
+        LogInfo("Create OnMissionState.\n");
+        state = std::make_shared<OnMissionState>();
+        break;
+
+    default:
+        LogWarning("Unknown mission.\n");
+        state = std::make_shared<TestMissionState>();
+        break;
+    }
+    return state;
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateStorageHandleState(void)
+{
+    std::shared_ptr<State> state = std::make_shared<StorageHandleState>();
+    // std::dynamic_pointer_cast<StorageHandleState>(state)->Init();
+    return state;
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateSdCardHandleState(void)
+{
+    std::shared_ptr<State> state = std::make_shared<SdCardHandleState>();
+    return state;
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateUpgradeState(void)
+{
+    std::shared_ptr<State> state = std::make_shared<UpgradeState>();
+    return state;
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateMediaHandleState(void)
+{
+    std::shared_ptr<State> state = std::make_shared<MediaHandleState>();
+    return state;
+}
+std::shared_ptr<State> MissionManagerMakePtr::CreateIdleState(void)
+{
+    std::shared_ptr<State> state = std::make_shared<IdleState>();
+    return state;
+}

application/MissionManager/src/MissionManagerMakePtr.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MISSION_MANAGER_MAKE_PTR_H
+#define MISSION_MANAGER_MAKE_PTR_H
+#include "IMcuManager.h"
+#include "IMissionManager.h"
+#include "IStateMachine.h"
+#include "StatusCode.h"
+#include <memory>
+class MissionManagerMakePtr
+{
+public:
+    MissionManagerMakePtr() = default;
+    virtual ~MissionManagerMakePtr() = default;
+    static std::shared_ptr<MissionManagerMakePtr> &GetInstance(std::shared_ptr<MissionManagerMakePtr> *impl = nullptr);
+    virtual const StatusCode CreateMissionManagerInstance(std::shared_ptr<IMissionManager> &instance);
+    virtual std::shared_ptr<State> CreateTopState(void);
+    virtual std::shared_ptr<State> CreateMissionState(const IpcMission &mission);
+    virtual std::shared_ptr<State> CreateStorageHandleState(void);
+    virtual std::shared_ptr<State> CreateSdCardHandleState(void);
+    virtual std::shared_ptr<State> CreateUpgradeState(void);
+    virtual std::shared_ptr<State> CreateMediaHandleState(void);
+    virtual std::shared_ptr<State> CreateIdleState(void);
+};
+#endif

application/MissionManager/src/MissionState.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MissionState.h"
+#include "IAppManager.h"
+#include "ILog.h"
+#include "MissionStateMachine.h"
+MissionState::MissionState(const std::string &name) : State(name)
+{
+    mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&MissionState::MediaReportHandle, this, _1);
+    mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
+        std::bind(&MissionState::SdCardEventReportHandle, this, _1);
+    mEventHandle[InternalStateEvent::CHECK_UPGRADE_FILE] = std::bind(&MissionState::CheckUpgradeFileHandle, this, _1);
+}
+void MissionState::GoInState()
+{
+    LogInfo(" ========== MissionState::GoInState.\n");
+}
+void MissionState::GoOutState()
+{
+    LogInfo(" ========== MissionState::GoOutState.\n");
+    LedsHandle::DeleteAllLeds();
+}
+bool MissionState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}
+bool MissionState::MediaReportHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);
+    return EXECUTED;
+}
+bool MissionState::SdCardEventReportHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::SD_CARD_HANDLE_STATE);
+    return EXECUTED;
+}
+bool MissionState::CheckUpgradeFileHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::UPGRADE_STATE);
+    return EXECUTED;
+}

application/MissionManager/src/MissionState.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MISSION_STATE_H
+#define MISSION_STATE_H
+#include "DataProcessing.h"
+#include "IStateMachine.h"
+#include "LedsHandle.h"
+class MissionState : public State,
+                     public DataProcessing,
+                     public LedsHandle,
+                     public std::enable_shared_from_this<MissionState>
+{
+public:
+    MissionState(const std::string &name);
+    virtual ~MissionState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+
+protected:
+    bool SdCardEventReportHandle(VStateMachineData *msg);
+
+private:
+    bool MediaReportHandle(VStateMachineData *msg);
+    bool CheckUpgradeFileHandle(VStateMachineData *msg);
+};
+#endif

application/MissionManager/src/MissionStateMachine.cpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MissionStateMachine.h"
+#include "DataProcessing.h"
+#include "ILog.h"
+#include "McuAskBase.h"
+#include "MissionManagerMakePtr.h"
+// #include "TopState.h"
+std::shared_ptr<MissionStateMachine> &MissionStateMachine::GetInstance(std::shared_ptr<MissionStateMachine> *impl)
+{
+    static auto instance = std::make_shared<MissionStateMachine>();
+    if (impl) {
+        instance = *impl;
+    }
+    return instance;
+}
+MissionStateMachine::MissionStateMachine()
+{
+    mStartMission = IpcMission::END;
+}
+void MissionStateMachine::Init(void)
+{
+    mStateMachine = std::make_shared<VStateMachineHandle>();
+    auto code = IStateMachine::GetInstance()->CreateStateMachine(mStateMachine);
+    if (!IsCodeOK(code)) {
+        LogError("Create state machine failed[%s].\n", code.mPrintStringCode(code));
+        return;
+    }
+    if (!mStateMachine->InitialStateMachine()) {
+        LogError("State machine init failed.\n");
+        return;
+    }
+    mStartMission = GetStartMission();
+    if (mStartMission == IpcMission::END) {
+        LogError("ipcmission error, will start test mode.\n");
+        mStartMission = IpcMission::TEST;
+    }
+    RunStateMachine(mStartMission);
+}
+void MissionStateMachine::UnInit(void)
+{
+    mStateMachine->StopHandlerThread();
+    mStateTree.clear();
+}
+StatusCode MissionStateMachine::SendStateMessage(const std::shared_ptr<VMissionData> &message)
+{
+    std::shared_ptr<VStateMessage> msg = std::make_shared<MissionMessage>(message);
+    mStateMachine->SendMessage(static_cast<int>(message->mEvent), msg);
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode MissionStateMachine::MessageExecutedLater(const std::shared_ptr<VMissionData> &message,
+                                                     long long &delayTimeMs)
+{
+    std::shared_ptr<VStateMessage> msg = std::make_shared<MissionMessage>(message);
+    mStateMachine->MessageExecutedLater(static_cast<int>(message->mEvent), msg, delayTimeMs);
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void MissionStateMachine::DelayMessage(VStateMachineData *msg)
+{
+    mStateMachine->DelayMessage(msg);
+}
+void MissionStateMachine::SwitchState(const SystemState &state)
+{
+    mStateMachine->SwitchState(mStateTree[state].get());
+}
+IpcMission MissionStateMachine::GetStartMission(void)
+{
+    class McuAskIpcMission : public McuAsk<IpcMission>, public McuAskBase
+    {
+    public:
+        McuAskIpcMission() : McuAskBase(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
+        {
+            mDataReply = IpcMission::END;
+        }
+        virtual ~McuAskIpcMission() = default;
+    };
+    std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskIpcMission>();
+    IMcuManager::GetInstance()->GetIpcMission(ask);
+    return std::dynamic_pointer_cast<McuAskIpcMission>(ask)->mDataReply;
+}
+void MissionStateMachine::RunStateMachine(const IpcMission &mission)
+{
+    LogInfo("Make all states and start the state machine, ipc mission = %s.\n",
+            IMcuManager::GetInstance()->PrintIpcMissionString(mission));
+    mStateTree[SystemState::TOP_STATE] = MissionManagerMakePtr::GetInstance()->CreateTopState();
+    mStateTree[SystemState::MISSION_STATE] = MissionManagerMakePtr::GetInstance()->CreateMissionState(mission);
+    mStateTree[SystemState::STORAGE_HANDLE_STATE] = MissionManagerMakePtr::GetInstance()->CreateStorageHandleState();
+    mStateTree[SystemState::SD_CARD_HANDLE_STATE] = MissionManagerMakePtr::GetInstance()->CreateSdCardHandleState();
+    mStateTree[SystemState::UPGRADE_STATE] = MissionManagerMakePtr::GetInstance()->CreateUpgradeState();
+    mStateTree[SystemState::MEDIA_HANDLE_STATE] = MissionManagerMakePtr::GetInstance()->CreateMediaHandleState();
+    mStateTree[SystemState::IDLE_STATE] = MissionManagerMakePtr::GetInstance()->CreateIdleState();
+    mStateMachine->StatePlus(mStateTree[SystemState::TOP_STATE].get(), nullptr);
+    mStateMachine->StatePlus(mStateTree[SystemState::MISSION_STATE].get(), mStateTree[SystemState::TOP_STATE].get());
+    mStateMachine->StatePlus(mStateTree[SystemState::STORAGE_HANDLE_STATE].get(),
+                             mStateTree[SystemState::MISSION_STATE].get());
+    mStateMachine->StatePlus(mStateTree[SystemState::SD_CARD_HANDLE_STATE].get(),
+                             mStateTree[SystemState::STORAGE_HANDLE_STATE].get());
+    mStateMachine->StatePlus(mStateTree[SystemState::UPGRADE_STATE].get(),
+                             mStateTree[SystemState::MISSION_STATE].get());
+    mStateMachine->StatePlus(mStateTree[SystemState::MEDIA_HANDLE_STATE].get(),
+                             mStateTree[SystemState::MISSION_STATE].get());
+    mStateMachine->StatePlus(mStateTree[SystemState::IDLE_STATE].get(), mStateTree[SystemState::MISSION_STATE].get());
+    mStateMachine->SetCurrentState(mStateTree[SystemState::TOP_STATE].get());
+    mStateMachine->StartStateMachine();
+    /**
+     * @brief The business can only be processed after the state machine is started.
+     *
+     */
+    std::shared_ptr<VMissionData> message =
+        std::make_shared<VMissionData>(static_cast<MissionEvent>(InternalStateEvent::STORAGE_HANDLE_STATE_INIT));
+    SendStateMessage(message);
+}

application/MissionManager/src/MissionStateMachine.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MISSION_STATE_MACHINE_H
+#define MISSION_STATE_MACHINE_H
+// #include "IDeviceManager.h"
+#include "IMcuManager.h"
+#include "IMissionManager.h"
+#include "IStateMachine.h"
+#include "StatusCode.h"
+#include <map>
+const bool NOT_EXECUTED = false;
+const bool EXECUTED = true;
+enum class SystemState
+{
+    TOP_STATE = 0,
+    MISSION_STATE,
+    STORAGE_HANDLE_STATE,
+    SD_CARD_HANDLE_STATE,
+    UPGRADE_STATE,
+    MEDIA_HANDLE_STATE,
+    IDLE_STATE,
+    END
+};
+class MissionStateMachine
+{
+public:
+    MissionStateMachine();
+    virtual ~MissionStateMachine() = default;
+    static std::shared_ptr<MissionStateMachine> &GetInstance(std::shared_ptr<MissionStateMachine> *impl = nullptr);
+    void Init(void);
+    void UnInit(void);
+    StatusCode SendStateMessage(const std::shared_ptr<VMissionData> &message);
+    StatusCode MessageExecutedLater(const std::shared_ptr<VMissionData> &message, long long &delayTimeMs);
+    void DelayMessage(VStateMachineData *msg);
+    void SwitchState(const SystemState &state);
+
+private:
+    IpcMission GetStartMission(void);
+    void RunStateMachine(const IpcMission &mission);
+
+private:
+    std::shared_ptr<VStateMachineHandle> mStateMachine;
+    std::map<SystemState, std::shared_ptr<State>> mStateTree;
+    IpcMission mStartMission;
+};
+#endif

application/MissionManager/src/OnMissionState.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "OnMissionState.h"
+#include "ILog.h"
+#include "IStorageManager.h"
+#include "MissionStateMachine.h"
+OnMissionState::OnMissionState() : MissionState("OnMissionState")
+{
+    // mEventHandle[InternalStateEvent::ANY_STATE_SD_STATUS_PERORIED] =
+    //     std::bind(&OnMissionState::SdCardEventReportSendToApp, this, _1);
+}
+void OnMissionState::GoInState()
+{
+    MissionState::GoInState();
+    LogInfo(" ========== OnMissionState::GoInState.\n");
+}
+void OnMissionState::GoOutState()
+{
+    MissionState::GoOutState();
+    LogInfo(" ========== OnMissionState::GoOutState.\n");
+}
+bool OnMissionState::SdCardEventReportSendToApp(VStateMachineData *msg)
+{
+    return EXECUTED;
+}

application/MissionManager/src/OnMissionState.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef ON_MISSION_STATE_H
+#define ON_MISSION_STATE_H
+#include "IStateMachine.h"
+#include "IStorageManager.h"
+#include "MissionState.h"
+class OnMissionState : public MissionState
+{
+public:
+    OnMissionState();
+    virtual ~OnMissionState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+
+private:
+    bool SdCardEventReportSendToApp(VStateMachineData *msg);
+};
+#endif

application/MissionManager/src/PirTrggeredMissionState.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "PirTriggeredMissionState.h"
+#include "ILog.h"
+#include "IStorageManager.h"
+#include "MissionStateMachine.h"
+PirTriggeredMissionState::PirTriggeredMissionState() : MissionState("PirTriggeredMissionState")
+{
+    // mEventHandle[InternalStateEvent::ANY_STATE_SD_STATUS_PERORIED] =
+    //     std::bind(&PirTriggeredMissionState::SdCardEventReportSendToApp, this, _1);
+}
+void PirTriggeredMissionState::GoInState()
+{
+    MissionState::GoInState();
+    LogInfo(" ========== PirTriggeredMissionState::GoInState.\n");
+}
+void PirTriggeredMissionState::GoOutState()
+{
+    MissionState::GoOutState();
+    LogInfo(" ========== PirTriggeredMissionState::GoOutState.\n");
+}
+bool PirTriggeredMissionState::SdCardEventReportSendToApp(VStateMachineData *msg)
+{
+    return EXECUTED;
+}

application/MissionManager/src/PirTriggeredMissionState.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef PIR_TRIGGERED_MISSION_STATE_H
+#define PIR_TRIGGERED_MISSION_STATE_H
+#include "IStateMachine.h"
+#include "IStorageManager.h"
+#include "MissionState.h"
+class PirTriggeredMissionState : public MissionState
+{
+public:
+    PirTriggeredMissionState();
+    virtual ~PirTriggeredMissionState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+
+private:
+    bool SdCardEventReportSendToApp(VStateMachineData *msg);
+};
+#endif

application/MissionManager/src/SdCardHandleState.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "SdCardHandleState.h"
+#include "IFilesManager.h"
+#include "ILog.h"
+#include "IMediaManager.h"
+#include "MissionStateMachine.h"
+SdCardHandleState::SdCardHandleState() : State("SdCardHandleState"), mSdCardStatus(StorageEvent::END)
+{
+    mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&SdCardHandleState::MediaReportHandle, this, _1);
+    mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
+        std::bind(&SdCardHandleState::SdCardEventHandle, this, _1);
+}
+void SdCardHandleState::GoInState()
+{
+    LogInfo(" ========== SdCardHandleState::GoInState.\n");
+}
+void SdCardHandleState::GoOutState()
+{
+    LogInfo(" ========== SdCardHandleState::GoOutState.\n");
+}
+bool SdCardHandleState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}
+bool SdCardHandleState::MediaReportHandle(VStateMachineData *msg)
+{
+    LogInfo(" MediaReportHandle.\n");
+    std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
+    std::shared_ptr<VMissionDataV2<MediaReportEvent>> data =
+        std::dynamic_pointer_cast<VMissionDataV2<MediaReportEvent>>(message->mMissionData);
+    if (!data) {
+        LogError("nullptr pointer.\n");
+        return NOT_EXECUTED;
+    }
+    if (StorageEvent::SD_CARD_INSERT != mSdCardStatus) {
+        /**
+         * @brief The SD card has not been mounted yet, cache the data for the quick start first.
+         *
+         */
+        LogWarning("Sd card is not inserted, cache data.\n");
+        mFileNeedToSave = std::make_shared<SaveFileInfo>(data->mData.mFileName);
+        return EXECUTED;
+    }
+    LogInfo("file = %s.\n", data->mData.mFileName.c_str());
+    SaveFileInfo saveFileInfo(data->mData.mFileName);
+    StatusCode code = IFilesManager::GetInstance()->SaveFile(saveFileInfo);
+    if (IsCodeOK(code) == false) {
+        LogError("SaveFile failed.\n");
+    }
+    return EXECUTED;
+}
+bool SdCardHandleState::SdCardEventHandle(VStateMachineData *msg)
+{
+    std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
+    std::shared_ptr<VMissionDataV2<StorageEvent>> data =
+        std::dynamic_pointer_cast<VMissionDataV2<StorageEvent>>(message->mMissionData);
+    LogInfo(" SdCardEventHandle event:%s.\n", IStorageManager::GetInstance()->PrintStringStorageEvent(data->mData));
+    if (mFileNeedToSave && StorageEvent::SD_CARD_INSERT == data->mData) {
+        LogInfo("Sd card is inserted for the first time.\n");
+        StatusCode code = IFilesManager::GetInstance()->SaveFile(*(mFileNeedToSave.get()));
+        if (IsCodeOK(code) == false) {
+            LogError("SaveFile failed.\n");
+        }
+        mFileNeedToSave.reset();
+    }
+    mSdCardStatus = data->mData;
+    if (StorageEvent::SD_CARD_INSERT == mSdCardStatus) {
+        std::shared_ptr<VMissionData> message =
+            std::make_shared<VMissionData>(static_cast<MissionEvent>(InternalStateEvent::CHECK_UPGRADE_FILE));
+        MissionStateMachine::GetInstance()->SendStateMessage(message);
+    }
+    return EXECUTED;
+}

application/MissionManager/src/SdCardHandleState.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef SD_CARD_HANDLE_STATE_H
+#define SD_CARD_HANDLE_STATE_H
+#include "DataProcessing.h"
+#include "IFilesManager.h"
+#include "IMediaManager.h"
+#include "IStateMachine.h"
+#include "IStorageManager.h"
+class SdCardHandleState : public State, public DataProcessing, public std::enable_shared_from_this<SdCardHandleState>
+{
+public:
+    SdCardHandleState();
+    virtual ~SdCardHandleState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+
+protected:
+    bool MediaReportHandle(VStateMachineData *msg);
+    bool SdCardEventHandle(VStateMachineData *msg);
+
+private:
+    StorageEvent mSdCardStatus;
+    std::shared_ptr<SaveFileInfo> mFileNeedToSave;
+};
+#endif

application/MissionManager/src/SetLedState.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "SetLedState.h"
+SetLedState::SetLedState(const LedState &state, const unsigned int &keepAliveTime, const unsigned int &blinkPeriod)
+    : mState(state), mKeepAliveTime(keepAliveTime), mBlinkPeriod(blinkPeriod)
+{
+}
+StatusCode SetLedState::GetLedState(LedState &state)
+{
+    state = mState;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+unsigned int SetLedState::GetKeepAliveTimeMs(void)
+{
+    return mKeepAliveTime;
+}
+unsigned int SetLedState::GetBlinkTimeMs(void)
+{
+    return mBlinkPeriod;
+}
+void SetLedState::DeleteState(void)
+{
+    mKeepAliveTime = DELETED_LED_STATE;
+}
+std::shared_ptr<SetLedState> SetLedState::ControlLed(const std::string &ledName, const LedState &state,
+                                                     const long int &keepAliveTime, const unsigned int &blinkPeriod)
+{
+    std::shared_ptr<SetLedState> ledState = std::make_shared<SetLedState>(state, keepAliveTime, blinkPeriod);
+    std::shared_ptr<LedControlContext> ledState2 = ledState;
+    IDeviceManager::GetInstance()->ControlLed(ledName, ledState2);
+    return ledState;
+}

application/MissionManager/src/SetLedState.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef SET_LED_STATE_H
+#define SET_LED_STATE_H
+#include "IDeviceManager.h"
+#include "LedControl.h"
+constexpr int LED_BLINKING_FAST_PERIOD = 500;
+constexpr int LED_BLINKING_SLOW_PERIOD = 1000;
+class SetLedState : public LedControlContext, public VSingleControl
+{
+public:
+    SetLedState(const LedState &state, const unsigned int &keepAliveTime = KEEP_ALIVE_FOREVER,
+                const unsigned int &blinkPeriod = LED_NOT_BLINK);
+    virtual ~SetLedState() = default;
+    StatusCode GetLedState(LedState &state) override;
+    unsigned int GetKeepAliveTimeMs(void) override;
+    unsigned int GetBlinkTimeMs(void) override;
+    void DeleteState(void);
+
+public:
+    static std::shared_ptr<SetLedState> ControlLed(const std::string &ledName, const LedState &state,
+                                                   const long int &keepAliveTime = KEEP_ALIVE_FOREVER,
+                                                   const unsigned int &blinkPeriod = LED_NOT_BLINK);
+
+private:
+    const LedState mState;
+    unsigned int mKeepAliveTime;
+    const unsigned int mBlinkPeriod;
+};
+#endif

application/MissionManager/src/StorageHandleState.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "StorageHandleState.h"
+#include "ILog.h"
+#include "IMediaManager.h"
+#include "MissionStateMachine.h"
+StorageHandleState::StorageHandleState() : State("StorageHandleState")
+{
+    mEventHandle[InternalStateEvent::STORAGE_HANDLE_STATE_INIT] =
+        std::bind(&StorageHandleState::StorageStartInitHandle, this, _1);
+}
+void StorageHandleState::GoInState()
+{
+    LogInfo(" ========== StorageHandleState::GoInState.\n");
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::SD_CARD_HANDLE_STATE);
+}
+void StorageHandleState::GoOutState()
+{
+    LogInfo(" ========== StorageHandleState::GoOutState.\n");
+}
+bool StorageHandleState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}
+void StorageHandleState::Init(void)
+{
+    std::shared_ptr<VStorageMoniter> monitor = shared_from_this();
+    IStorageManager::GetInstance()->SetMonitor(monitor);
+}
+void StorageHandleState::UnInit(void)
+{
+}
+void StorageHandleState::ReportEvent(const StorageEvent &event)
+{
+    LogInfo("StorageHandleState::ReportEvent.\n");
+    std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<StorageEvent>>(
+        static_cast<MissionEvent>(InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED), event);
+    MissionStateMachine::GetInstance()->SendStateMessage(message);
+    std::shared_ptr<VMissionData> message2 = std::make_shared<VMissionDataV2<StorageEvent>>(
+        static_cast<MissionEvent>(InternalStateEvent::ANY_STATE_SD_STATUS_PERORIED), event);
+    MissionStateMachine::GetInstance()->SendStateMessage(message2);
+}
+bool StorageHandleState::StorageStartInitHandle(VStateMachineData *msg)
+{
+    Init();
+    return EXECUTED;
+}

application/MissionManager/src/StorageHandleState.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef STORAGE_HANDLE_STATE_H
+#define STORAGE_HANDLE_STATE_H
+#include "DataProcessing.h"
+#include "IMediaManager.h"
+#include "IStateMachine.h"
+#include "IStorageManager.h"
+class StorageHandleState : public State,
+                           public DataProcessing,
+                           public VStorageMoniter,
+                           public std::enable_shared_from_this<StorageHandleState>
+{
+public:
+    StorageHandleState();
+    virtual ~StorageHandleState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+    void Init(void);
+    void UnInit(void);
+
+private: // About VStorageMoniter
+    void ReportEvent(const StorageEvent &event) override;
+    bool StorageStartInitHandle(VStateMachineData *msg);
+};
+#endif

application/MissionManager/src/TestMissionState.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "TestMissionState.h"
+#include "IAppManager.h"
+#include "ILog.h"
+#include "IStorageManager.h"
+#include "MissionStateMachine.h"
+TestMissionState::TestMissionState() : MissionState("TestMissionState")
+{
+    mEventHandle[InternalStateEvent::ANY_STATE_SD_STATUS_PERORIED] =
+        std::bind(&TestMissionState::SdCardEventReportSendToApp, this, _1);
+    mEventHandle[InternalStateEvent::RESET_KEY_MEDIA_TASK] =
+        std::bind(&TestMissionState::ResetKeyMediaTaskHandle, this, _1);
+    mKeyClickHandle["reset"] = std::bind(&TestMissionState::ClickResetKey, this, _1);
+}
+void TestMissionState::GoInState()
+{
+    MissionState::GoInState();
+    LogInfo(" ========== TestMissionState::GoInState.\n");
+    AppParam mAppParam(APP_MANAGER_DEVICE_IP, APP_MANAGER_HTTP_SERVER_PORT, APP_MANAGER_TCP_SERVER_PORT); // TODO:
+    IAppManager::GetInstance()->Init(mAppParam);
+    std::shared_ptr<VAppMonitor> monitor =
+        std::dynamic_pointer_cast<TestMissionState>(MissionState::shared_from_this());
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    ControlDeviceStatusLed(DeviceStatus::NORMAL);
+}
+void TestMissionState::GoOutState()
+{
+    MissionState::GoOutState();
+    LogInfo(" ========== TestMissionState::GoOutState.\n");
+}
+bool TestMissionState::SdCardEventReportSendToApp(VStateMachineData *msg)
+{
+    std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
+    std::shared_ptr<VMissionDataV2<StorageEvent>> data =
+        std::dynamic_pointer_cast<VMissionDataV2<StorageEvent>>(message->mMissionData);
+    LogInfo(" SdCardEventHandle event:%s.\n", IStorageManager::GetInstance()->PrintStringStorageEvent(data->mData));
+    SdCardStatus status = SdCardStatusConvert(data->mData);
+    IAppManager::GetInstance()->SetSdCardStatus(status);
+    return EXECUTED;
+}
+bool TestMissionState::ResetKeyMediaTaskHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::MEDIA_HANDLE_STATE);
+    return EXECUTED;
+}
+bool TestMissionState::ClickResetKey(const KeyEventData &data)
+{
+    LogInfo("reset key click:make a media task.\n");
+    // std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<MediaReportEvent>>(
+    //     static_cast<MissionEvent>(InternalStateEvent::MEDIA_REPORT_EVENT), event);
+    // MissionStateMachine::GetInstance()->SendStateMessage(message);
+    std::shared_ptr<VMissionData> message =
+        std::make_shared<VMissionData>(static_cast<MissionEvent>(InternalStateEvent::RESET_KEY_MEDIA_TASK));
+    MissionStateMachine::GetInstance()->SendStateMessage(message);
+    return EXECUTED;
+}
+SdCardStatus TestMissionState::SdCardStatusConvert(const StorageEvent &event)
+{
+    switch (event) {
+    case StorageEvent::SD_CARD_INSERT:
+        return SdCardStatus::NORMAL;
+    case StorageEvent::SD_CARD_REMOVE:
+        return SdCardStatus::NOT_INSERTED;
+    case StorageEvent::SD_ABNORMAL:
+        return SdCardStatus::NOT_INSERTED;
+    default:
+        LogError("SdCardStatusConvert failed.\n");
+        return SdCardStatus::END;
+    }
+}

application/MissionManager/src/TestMissionState.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef TEST_MISSION_STATE_H
+#define TEST_MISSION_STATE_H
+#include "AppMonitor.h"
+#include "IStateMachine.h"
+#include "IStorageManager.h"
+#include "MissionState.h"
+class TestMissionState : public MissionState, public AppMonitor
+{
+public:
+    TestMissionState();
+    virtual ~TestMissionState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+
+private:
+    bool SdCardEventReportSendToApp(VStateMachineData *msg);
+    bool ResetKeyMediaTaskHandle(VStateMachineData *msg);
+    bool ClickResetKey(const KeyEventData &data);
+
+private:
+    SdCardStatus SdCardStatusConvert(const StorageEvent &event);
+};
+#endif

application/MissionManager/src/TopState.cpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "TopState.h"
+#include "ILog.h"
+#include "IMediaManager.h"
+#include "KeyControl.h"
+#include "MissionStateMachine.h"
+TopState::TopState() : State("TopState")
+{
+    mEventHandle[InternalStateEvent::STORAGE_HANDLE_STATE_INIT] =
+        std::bind(&TopState::StorageStartInitHandle, this, _1);
+}
+void TopState::GoInState()
+{
+    LogInfo(" ========== TopState::GoInState.\n");
+    std::shared_ptr<VMcuMonitor> mcuMonitor = std::dynamic_pointer_cast<VMcuMonitor>(shared_from_this());
+    McuMonitor::Init(mcuMonitor);
+    std::shared_ptr<VMediaMonitor> mediaMonitor = std::dynamic_pointer_cast<VMediaMonitor>(shared_from_this());
+    IMediaManager::GetInstance()->SetMediaMonitor(mediaMonitor);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::MISSION_STATE);
+    std::shared_ptr<VKeyMonitor> keysMonitor = std::dynamic_pointer_cast<VKeyMonitor>(shared_from_this());
+    IDeviceManager::GetInstance()->SetAllKeysMonitor(keysMonitor);
+}
+void TopState::GoOutState()
+{
+    LogInfo(" ========== TopState::GoOutState.\n");
+}
+bool TopState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}
+StatusCode TopState::ReportEvent(const MediaReportEvent &event)
+{
+    LogInfo(" ReportEvent:\n");
+    std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<MediaReportEvent>>(
+        static_cast<MissionEvent>(InternalStateEvent::MEDIA_REPORT_EVENT), event);
+    MissionStateMachine::GetInstance()->SendStateMessage(message);
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void TopState::KeyEventReport(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs)
+{
+    LogInfo(" KeyEventReport:key name = %s, key event = %s, time = %d\n",
+            keyName.c_str(),
+            PrintKeyEvent(static_cast<KeyEvent>(event)),
+            timeMs);
+    KeyEventData data(keyName, static_cast<KeyEvent>(event), timeMs);
+    std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<KeyEventData>>(
+        static_cast<MissionEvent>(InternalStateEvent::KEY_EVENT_HANDLE), data);
+    MissionStateMachine::GetInstance()->SendStateMessage(message);
+}
+bool TopState::StorageStartInitHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);
+    return EXECUTED;
+}

application/MissionManager/src/TopState.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef TOP_STATE_H
+#define TOP_STATE_H
+#include "DataProcessing.h"
+#include "IDeviceManager.h"
+#include "IMediaManager.h"
+#include "IStateMachine.h"
+#include "McuMonitor.h"
+class TopState : public State,
+                 public DataProcessing,
+                 public VMediaMonitor,
+                 public McuMonitor,
+                 public VKeyMonitor,
+                 public std::enable_shared_from_this<TopState>
+{
+public:
+    TopState();
+    virtual ~TopState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+
+private: // About VMediaMonitor
+    StatusCode ReportEvent(const MediaReportEvent &event) override;
+
+private: // About KeyMonitor
+    void KeyEventReport(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs) override;
+
+private:
+    bool StorageStartInitHandle(VStateMachineData *msg);
+};
+#endif

application/MissionManager/src/UpgradeState.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "UpgradeState.h"
+#include "IHuntingUpgrade.h"
+#include "ILog.h"
+#include "IMediaManager.h"
+#include "MissionStateMachine.h"
+UpgradeState::UpgradeState() : State("UpgradeState")
+{
+    mEventHandle[InternalStateEvent::CHECK_UPGRADE_FILE] = std::bind(&UpgradeState::CheckUpgradeFileHandle, this, _1);
+}
+void UpgradeState::GoInState()
+{
+    LogInfo(" ========== UpgradeState::GoInState.\n");
+}
+void UpgradeState::GoOutState()
+{
+    LogInfo(" ========== UpgradeState::GoOutState.\n");
+}
+bool UpgradeState::ExecuteStateMsg(VStateMachineData *msg)
+{
+    return DataProcessing::EventHandle(msg);
+}
+bool UpgradeState::CheckUpgradeFileHandle(VStateMachineData *msg)
+{
+    // TODO: need to improve:It cannot be blocked.
+    IHuntingUpgrade::GetInstance()->CheckUpgradeFile();
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::IDLE_STATE);
+    return EXECUTED;
+}

application/MissionManager/src/UpgradeState.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef UPGRADE_STATE_H
+#define UPGRADE_STATE_H
+#include "DataProcessing.h"
+#include "IMediaManager.h"
+#include "IStateMachine.h"
+class UpgradeState : public State, public DataProcessing, public std::enable_shared_from_this<UpgradeState>
+{
+public:
+    UpgradeState();
+    virtual ~UpgradeState() = default;
+    void GoInState() override;
+    void GoOutState() override;
+    bool ExecuteStateMsg(VStateMachineData *msg) override;
+
+private:
+    bool CheckUpgradeFileHandle(VStateMachineData *msg);
+};
+#endif

application/main/CMakeLists.txt

@@ -0,0 +1,65 @@
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+
+set(MAIN_INCLUDE_PATH     "${APPLICATION_SOURCE_PATH}/main/src" CACHE STRING INTERNAL FORCE)
+set(MAIN_INCLUDE_PATH     "${MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/StatusCode/include" CACHE STRING INTERNAL FORCE)
+set(MAIN_INCLUDE_PATH     "${MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/Log/include" CACHE STRING INTERNAL FORCE)
+set(MAIN_INCLUDE_PATH     "${MAIN_INCLUDE_PATH};${HAL_SOURCE_PATH}/include" CACHE STRING INTERNAL FORCE)
+include_directories(${MAIN_INCLUDE_PATH})
+
+link_directories(
+    ${LIBS_OUTPUT_PATH}
+    ${HAL_SOURCE_PATH}/include
+)
+
+aux_source_directory(./ SRC_FILES)
+# aux_source_directory(./src SRC_FILES)
+
+# Mark src files for test.
+file(GLOB_RECURSE MAIN_SRC_FILE_THIS src/*.cpp src/*.c)
+set(MAIN_SRC_FILE     "${MAIN_SRC_FILE_THIS}" CACHE STRING INTERNAL FORCE)
+
+
+set(TARGET_LIB MainLib)
+add_library(${TARGET_LIB} STATIC ${MAIN_SRC_FILE_THIS})
+set(TARGET_NAME ipc_x86)
+add_executable(${TARGET_NAME} ${SRC_FILES})
+
+set(LINK_LIB StatusCode Log Hal pthread dl)
+set(MAIN_LINK_LIB     "${LINK_LIB}" CACHE STRING INTERNAL FORCE)
+target_link_libraries(${TARGET_LIB} ${MAIN_LINK_LIB})
+target_link_libraries(${TARGET_NAME} ${TARGET_LIB})
+if(${TEST_COVERAGE} MATCHES "true")
+    target_link_libraries(${TARGET_NAME} gcov)
+endif()
+
+if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
+add_custom_target(
+    ipc_x86_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${MAIN_SRC_FILE_THIS}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${APPLICATION_SOURCE_PATH}/main
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    ipc_x86_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${SRC_FILES} ${HEADER_FILES} ${MAIN_SRC_FILE_THIS}
+    WORKING_DIRECTORY ${APPLICATION_SOURCE_PATH}/main
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make ipc_x86_code_check
+    COMMAND make ipc_x86_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()

application/main/main.cpp

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "ILog.h"
+#include "MainThread.h"
+#include <thread>
+int main(int argc, char *argv[])
+{
+    MainThread::GetInstance()->Init();
+    MainThread::GetInstance()->Runing();
+    MainThread::GetInstance()->UnInit();
+    return 0;
+}

application/main/src/MainThread.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "MainThread.h"
+#include "IHalCpp.h"
+#include "ILog.h"
+#include <thread>
+MainThread::MainThread()
+{
+    mMainThreadRuning = false;
+}
+std::shared_ptr<MainThread> &MainThread::GetInstance(std::shared_ptr<MainThread> *impl)
+{
+    static auto instance = std::make_shared<MainThread>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+StatusCode MainThread::Init(void)
+{
+    CreateLogModule();
+    ILogInit(LOG_EASYLOGGING);
+    CustomizationInit();
+    mMainThreadRuning = true;
+    CreateAllModules();
+    // IHalInit();
+    IHalCpp::GetInstance()->Init();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode MainThread::UnInit(void)
+{
+    IHalCpp::GetInstance()->UnInit();
+    DestoryAllModules();
+    ILogUnInit();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode MainThread::CreateAllModules(void)
+{
+    // CreateLogModule();
+    // CreateHalModule();
+    CreateHalCppModule();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void MainThread::DestoryAllModules(void)
+{
+}
+void MainThread::ResetAllPtrMaker(void)
+{
+}
+void MainThread::Runing(void)
+{
+    while (mMainThreadRuning) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+}

application/main/src/MainThread.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MAIN_THREAD_H
+#define MAIN_THREAD_H
+#include "StatusCode.h"
+#include <memory>
+class MainThread
+{
+public:
+    MainThread();
+    virtual ~MainThread() = default;
+    static std::shared_ptr<MainThread> &GetInstance(std::shared_ptr<MainThread> *impl = nullptr);
+    virtual StatusCode Init(void);
+    virtual StatusCode UnInit(void);
+    void Runing(void);
+    void Exit(void)
+    {
+        mMainThreadRuning = false;
+    }
+    virtual void CustomizationInit(void)
+    {
+    }
+
+private:
+    StatusCode CreateAllModules(void);
+    void DestoryAllModules(void);
+    void ResetAllPtrMaker(void);
+
+private:
+    bool mMainThreadRuning;
+};
+#endif // !MAIN_THREAD_H

middleware/AppManager/CMakeLists.txt

@@ -0,0 +1,62 @@
+
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+include(${MIDDLEWARE_SOURCE_PATH}/AppManager/build/app_manager.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+include_directories(
+    ./src
+    ./include
+    ${UTILS_SOURCE_PATH}/StatusCode/include
+    ${UTILS_SOURCE_PATH}/Log/include
+    ${UTILS_SOURCE_PATH}/FxHttpServer/include
+    ${UTILS_SOURCE_PATH}/WebServer/include
+    ${UTILS_SOURCE_PATH}/TcpModule/include
+    ${HAL_SOURCE_PATH}/include
+    ${EXTERNAL_SOURCE_PATH}/cJSON-1.7.17
+)
+#do not rely on any other library
+#link_directories(
+#)
+
+aux_source_directory(./src SRC_FILES)
+aux_source_directory(./src/Protocol/SixFrame SRC_FILES)
+
+set(TARGET_NAME AppManager)
+add_library(${TARGET_NAME} STATIC ${SRC_FILES})
+
+target_link_libraries(${TARGET_NAME} WebServer TcpModule Hal cjson-static StatusCode Log)
+
+if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
+add_custom_target(
+    AppManager_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${SRC_FILES}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/AppManager
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    AppManager_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${SRC_FILES} ${HEADER_FILES}
+    WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/AppManager
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make AppManager_code_check
+    COMMAND make AppManager_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()
+
+define_file_name(${TARGET_NAME})
+
+file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
+install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

middleware/AppManager/README.md

@@ -0,0 +1,313 @@
+# 1. 打猎相机APP（WiFi单机版）设计文档
+
+| 版本 | 时间 | 说明 |
+| ---- | ---- | ---- |
+| V1.0 | 2024-5-21 | 首次评审。 |
+| V1.1 | 2024-5-25 | 增加标准设置项和动态设置参数协议。 |
+| V1.2 | 2024-5-27 | 完善自定义协议描述。 |
+
+## 1.1. 概述
+
+    打猎相机手机APP是用于查看相机的实时视频，回放保存在SD卡的MP4视频文件，以及对相机进行设置/管理。
+
+**备注：** 本文基于六帧探APP现有功能，最小修改量实现APP的定制开发。
+
+## 1.2. APP功能详解
+
+### 1.2.1. 主页
+
+<div style="text-align:center; width: 100%;">
+    <img src="./build/picture/main_page.png" alt="替代文本" style="text-align:center; width: 30%; height: auto; max-width: 400px; border: 2px solid black;">
+    <h5 style="text-align: center;">主页图示</h5>
+</div>
+
+&emsp;&emsp;主页分三大块：相机管理，本地相册，更多（APP相关）。
+
+#### 1.2.1.1. 相机管理
+
+* 相机管理-添加设备
+
+&emsp;&emsp;手机连接设备的AP热点后，自动搜索设备，并添加到设备列表。可多次添加多个设备，设备列表中可对设备进行删除。
+
+* 相机管理-连接设备
+
+&emsp;&emsp;APP只能连接当前WiFi设备，如果当前WiFi未发现设备，提示用户正确连接设备WiFi。连接设备后，跳转到设备管理页面。
+
+#### 1.2.1.2. 本地相册
+
+<div style="text-align:center; width: 100%;">
+    <img src="./build/picture/phone_local_files.png" alt="替代文本" style="text-align:center; width: 30%; height: auto; max-width: 400px; border: 2px solid black;">
+    <h5 style="text-align: center;">本地相册图示</h5>
+</div>
+
+&emsp;&emsp;本地相册可查找从相机下载到手机本地的文件（视频/图片）。“紧急”分类里面显示记录仪碰撞时的文件。
+
+&emsp;&emsp;在打猎机的产品形态中，“紧急”分类显示PIR触发时拍摄的图片/视频。
+
+#### 1.2.1.3. 更多
+
+&emsp;&emsp;保持不变。
+
+#### 1.2.1.4. 问题列表
+
+1. 如果用户未对设备出厂设置进行修改，如何区分不同的设备？
+答：通过wifi名称进行区分。
+2. 如果APP面对多个出厂设备（设备信息完全一样），如何快速判断连接的是哪个设备？
+答：音频互动。滴一声表示链接成功。
+
+### 1.2.2. 相机连接页
+
+&emsp;&emsp;APP连接设备后，可手动开始/停止录像；可手动拍照。可跳转到相机文件/相机设置界面。
+
+<div style="text-align:center; width: 100%;">
+    <img src="./build/picture/device.png" alt="替代文本" style="text-align:center; width: 30%; height: auto; max-width: 400px; border: 2px solid black;">
+    <h5 style="text-align: center;">相机连接图示</h5>
+</div>
+
+#### 1.2.2.1. 实时播放界面
+
+* 实时播放rtsp视频流；
+* 可手动开始/停止录像；
+* 可手动拍照；
+
+#### 1.2.2.2. 相机文件
+
+&emsp;&emsp;对相机端的文件进行分类显示。可下载到手机本地/删除/编辑等操作。
+
+<div style="text-align:center; width: 100%;">
+    <img src="./build/picture/device_local_files.png" alt="替代文本" style="text-align:center; width: 30%; height: auto; max-width: 400px; border: 2px solid black;">
+    <h5 style="text-align: center;">设备端相册图示</h5>
+</div>
+
+##### 1.2.2.2.1. 设备端文件分类
+
+1. PIR触发图片/视频；
+2. 手动抓拍图片/视频；
+3. 定时抓拍图片/视频；
+4. 全部文件；
+
+**文件分类整改方案：**
+
+&emsp;&emsp;目前APP支持的四种协议类型显示：循环/拍照/紧急/停车。打猎相机的分类定义为全部/PIR/手动/定时，根据协议进行一一对应回复，全部-循环，PIR-紧急，手动-拍照，定时-停车，在不修改协议的情况下，只需要修改APP的显示文字即可实现APP定制开发。
+
+##### 1.2.2.2.2. 相机设置
+
+&emsp;&emsp;对设备的参数进行读取/修改。目前基于记录仪产品的设置内容无法满足打猎机产品需求。
+
+<div style="text-align:center; width: 100%;">
+    <img src="./build/picture/settings.png" alt="替代文本" style="text-align:center; width: 30%; height: auto; max-width: 400px; border: 2px solid black;">
+    <h5 style="text-align: center;">相机设置图示</h5>
+</div>
+
+**记录仪当前参数列表：**
+
+| 参数名称 | 数据类型 | 取值说明 | 公版支持 | 备注 |
+| ---- | ---- | ---- | ---- | ---- |
+| 记录仪WiFi名称 | ---- | ---- | 支持 | ---- |
+| 记录仪WiFi密码 | ---- | ---- | 支持 | ---- |
+| 固件版本 | ---- | ---- | 支持 | ---- |
+| 格式化存储卡 | ---- | ---- | 支持 | ---- |
+| 恢复出厂设置 | ---- | ---- | 支持 | ---- |
+
+**打猎机参数需求列表：**
+
+&emsp;&emsp;**下述列表中，未支持的设置项作为标准设置项需求，APP在切换语言时需要做对应的翻译。**
+
+| 参数名称 | 数据类型 | 取值说明 | 公版支持 | 备注 |
+| ---- | ---- | ---- | ---- | ---- |
+| 记录仪WiFi名称 | ---- | ---- | 支持 | ---- |
+| 记录仪WiFi密码 | ---- | ---- | 支持 | ---- |
+| 固件版本 | ---- | ---- | 支持 | 仅显示 |
+| ---- | ---- | ---- | ---- | ---- |
+| 电量 | ---- | ---- | 未支持 | 仅显示 |
+| 工作模式 | 数字 | 0：图片<br>1：图片+视频 | 未支持 | ---- |
+| 连拍|数字 | 1/2/3 | 未支持 | 单位：P |
+| 连拍间隔 | 数字 | 0~60 | 未支持 | 单位：s |
+| 图片大小 | 数字 | 8/16/24/32/40 | 未支持 | 单位：M |
+| 录像分辨率 | 数字 | 0：WVGA<br>1：HD<br>2：FHD | 未支持 | ---- |
+| 录像帧率 | 数字 | 15/30 | 未支持 | 单位：fps |
+| 视频长度 | 数字 | 10/15 | 未支持 | 单位：s |
+| PIR延时 | 时间 | 00:00:00-23:59:59 | 未支持 | 两个PIR之间的最小间隔 |
+| 定时工作 | 时间 | 00:00:00-23:59:59 | 未支持 | 定时唤醒 |
+| 工作时间 | 时间 | 起始的时间设置<br>例如：起点20：00至终点6：00 | 未支持 | ---- |
+| 循环存储 | 数字 | 0：OFF<br>1：ON | 未支持 | ---- |
+| 红外灯功率 | 数字 | 0/1/2 | 未支持 | 低/中/高 |
+| PIR灵敏度 | 数字 | 0~9 | 未支持 | ---- |
+| 恢复出厂 | ---- | ---- | 支持 | 功能 |
+| 格式化SD卡 | ---- | ---- | 支持 | 功能 |
+| 重启 | ---- | ---- | 未支持 | 功能 |
+
+#### 1.2.2.3. 问题列表
+
+1. 针对软件迭代需求，除了一些和APP业务逻辑相关的参数需要特殊处理外，是否可以通过协议来获取设备自定义的参数设置？方便设备可以随意的增加/删除设置参数。
+答：==已经支持==，看协议能力。
+2. 没发现升级功能。
+答：公版APP不支持升级功能。
+
+## 1.3. APP定制整改总结
+
+&emsp;&emsp;**基于WiFi公版基础，未修改原有协议，做界面显示定制和增量开发，方案可控。**
+
+1. “记录仪”统一修改为“相机”；
+答：需要定制。
+2. 本地相册-“紧急”分类，改为“PIR”；
+3. **新增标准的设置项，见前面描述：打猎机参数需求列表；**
+4. APP连接设备后，自动录像，改为默认不录像，可手动录像；
+答：设备返回非记录仪即可，见能力集。
+5. APP上的“循环”改成“全部”，“拍照”改成“手动”，“紧急”改成“PIR”，“停车”改成“定时”，**全部包括手动/PIR/定时**；
+6. **相机设置需要新增设备自定义设置项功能；**
+
+## 1.4. 设置界面动态渲染方案设计
+
+&emsp;&emsp;为了实现设置参数可自由定制，例如：可随意的增加/减少常见类型的参数设置。**此功能APP无需多语言翻译，直接显示协议字符即可**。
+
+### 1.4.1. 常见设置类型
+
+| 参数类型 | 数据类型 | 取值说明 | 备注 |
+| ---- | ---- | ---- | ---- |
+| 显示参数 | ---- | 协议自定义 | 仅显示，无法修改 |
+| 开关 | 数字 | 只有0和1<br>0 - 关<br>1 - 开 | 只能设置开/关 |
+| 数字输入框 | 数字（带单位/取值范围） | 协议指定取值范围 | 手动输入 |
+| 任意输入框 | 无限制 | 无限制 | 手动输入任意字符 |
+| 时间 | 时间 | ---- | 设置时间 |
+| 功能 | 功能按钮 | 取消/确定 | 例如：格式化/恢复出厂/重启<br>可通过协议自由定义，协议带显示字符 |
+| 选项 | 数字 | ---- | 协议带选项对应的文字字符 |
+
+### 1.4.2. 动态渲染设置界面
+
+#### 1.4.2.1. 新增动态设置参数协议
+
+**获取动态设置参数列表**
+
+|  |  |
+| ---- | ---- |
+| 描述 | 获取动态设置参数列表。 |
+| 接口 | http://192.168.1.100/app/getdynamicparam |
+| 参数 | ?index=all&language=xx // 获取全部动态设置参数<br>?index=6&language=xx // 获取索引号为6的动态设置参数 |
+| 参数说明 | index：设置项索引，all代表全部<br>language：APP当前语言，由六帧探定义值，设备根据该值回传对应语言的字符串 |
+| 返回参数 | result:0-成功，-1-失败<br>info:动态参数列表 |
+
+**获取全部动态参数返回示例：**
+
+```code
+{
+    "result": 0,                              // 0代表成功，-1代表失败
+    "info":
+    [
+        {
+            "name": "SettingName",            // 直接显示在APP界面
+            "type": "label",                  // 显示控件类型，只显示
+            "value": "0-表示字符串",           // 当前值
+            "index": 0                        // 设置项索引，直接回传给设备
+        },
+        {
+            "name": "NumberName",
+            "type": "inputnum",               // 数字输入框，带单位显示
+            "value": 123456789,
+            "length": 9,                      // 输入字符最大长度
+            "unit": "s",                      // 单位，可选，如果有则显示单位
+            "index": 1                        // 设置项索引，直接回传给设备
+        },
+        {
+            "name": "SwitchName",
+            "type": "switch",                 // 开关，0-关，1-开
+            "value": 0,                       // 当前值，0-关，1-开
+            "index": 2                        // 设置项索引，直接回传给设备
+        },
+        {
+            "name": "InputStringName",
+            "type": "inputstring",            // 任意字符（数字/字母/常见字符）输入框
+            "value": "0123abcDEF!@#",         // 当前值
+            "length": 15,                     // 输入字符最大长度
+            "index": 3                        // 设置项索引，直接回传给设备
+        },
+        {
+            "name": "TimeSettingName",
+            "type": "time",                   // 时间设置(24小时制)，格式：hh-mm-ss
+            "value": "23:59:59",              // 当前值，格式：hh-mm-ss
+            "index": 4                        // 设置项索引，直接回传给设备
+        },
+        {
+            "name": "ConfirmName",
+            "tips": "Confirm?",               // 提示信息，没有时使用name
+            "type": "comfirm",                // 功能按钮(确认框)
+            "index": 5                        // 设置项索引，直接回传给设备
+        },
+        {
+            "name": "OptionName",
+            "type": "option",                 // 选项设置
+            "items": ["Option0","Option1"],   // 选项列表，格式：["选项1","选项2",...]
+            "value": 1,                       // 当前值, 索引值，0-Option0，1-Option1
+            "index": 6                        // 设置项索引，直接回传给设备
+        }
+    ]
+}
+```
+
+响应值描述：
+
+| 参数名 | 类型 | 描述 |
+| ---- | ---- | ---- |
+| name | String | 直接显示在APP |
+| type | String | 控件类型：<br>label-字符串，仅显示内容，无法修改<br>inputnum-数字<br>switch-开关(0-关，1-开) <br>inputstring-任意字符（数字/字母/常见字符）输入<br>time-时间设置<br>comfirm-功能按钮(确认框)<br>option-选项设置 |
+| value | ---- | 当前值，类型根据type定义来确定 |
+| length | int | 输入框的长度限制 |
+| unit | String | 单位，如果有则在APP界面显示 |
+| index | int | 索引值，设备使用，根据索引值知道修改哪个参数 |
+
+**动态设置项设置协议**
+
+|  |  |
+| ---- | ---- |
+| 描述 | 动态设置项设置协议 |
+| 接口 | http://192.168.1.100/app/dynamicparamset |
+| 参数 | ?index=1&value=0123456789 // 数字输入框<br>?index=2&value=0 // 开关，0-关，1-开<br>?index=3&value=0123abcDEF!@# // 任意字符输入框<br>?index=4&value=23:59:59 // 时间<br>?index=5&value=0 // 0-取消；1-确认 <br>?index=6&value=1 // 0-Option0，1-Option1，以此类推 |
+| 返回参数 | result:0-成功，-1-失败<br>返回成功后重新获取动态参数显示 |
+
+**动态设置项设置返回示例：**
+
+```code
+{
+    "result" : 0,
+    "info"   : "success."
+}
+```
+
+**动态参数显示/设置UML时序图：**
+
+```mermaid
+sequenceDiagram
+participant APP
+participant CAMERA
+APP ->> APP:进入设置界面
+APP ->> +CAMERA:http:getdynamicparam?index=all&language=xx
+CAMERA -->> -APP:return
+loop 设置界面停留
+    opt 用户切换语言
+    note over APP: 语言切换后，APP重新获取动态参数
+        APP ->> +CAMERA:http:getdynamicparam?index=2&language=xx
+        CAMERA -->> -APP:return
+    end
+    opt 用户修改参数
+        APP ->> APP:用户修改参数
+        APP ->> +CAMERA:http:dynamicparamset?index=2
+        CAMERA -->> -APP:return
+        alt result=0
+            APP ->> APP:修改成功
+            APP ->> +CAMERA:http:getdynamicparam?index=2&language=xx
+            CAMERA -->> -APP:return
+            APP ->> APP:刷新设置项显示
+        else result=-1
+            APP ->> APP:修改失败
+        end
+    end
+end
+opt 设备端修改参数
+    note over CAMERA: 设备端修改参数未能同步（未发现同步协议）
+end
+APP ->> APP:退出设置界面
+```
+
+### 1.4.3. 拓展规划
+
+&emsp;&emsp;后续如何拓展为4G版本？

middleware/AppManager/build/app_manager.cmake

@@ -0,0 +1,18 @@
+
+if (NOT DEFINED APP_MANAGER_DEVICE_IP)
+    set(APP_MANAGER_DEVICE_IP "localhost")
+endif()
+add_definitions(-DAPP_MANAGER_DEVICE_IP=\"${APP_MANAGER_DEVICE_IP}\")
+
+if (NOT DEFINED APP_MANAGER_HTTP_SERVER_PORT)
+    message(FATAL_ERROR "You should set http listen port.
+    Example: set(APP_MANAGER_HTTP_SERVER_PORT  \"8888\")
+    Refer to:${IPC_SDK_PATH}/builde/cmake/toolchain/linux.toolchain.cmake")
+endif()
+add_definitions(-DAPP_MANAGER_HTTP_SERVER_PORT=${APP_MANAGER_HTTP_SERVER_PORT})
+if (NOT DEFINED APP_MANAGER_TCP_SERVER_PORT)
+    message(FATAL_ERROR "You should set TCP listen port.
+    Example: set(APP_MANAGER_TCP_SERVER_PORT  \"8888\")
+    Refer to:${IPC_SDK_PATH}/builde/cmake/toolchain/linux.toolchain.cmake")
+endif()
+add_definitions(-DAPP_MANAGER_TCP_SERVER_PORT=${APP_MANAGER_TCP_SERVER_PORT})

middleware/AppManager/include/IAppManager.h

@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef I_APP_EMANAGER_H
+#define I_APP_EMANAGER_H
+#include "StatusCode.h"
+#include <iostream>
+#include <memory>
+#include <vector>
+bool CreateAppManagerModule(void);
+bool DestroyAppManagerModule(void);
+enum class ResposeResult
+{
+    SUCCESSFUL = 0,
+    FAILED,
+    END
+};
+enum class UploadCommand
+{
+    UPGRADE_CPU = 0,
+    END
+};
+enum class ChargeStatus
+{
+    UNCHARGED = 0,
+    CHARGING,
+    END
+};
+enum class SdCardStatus
+{
+    NORMAL = 0,
+    UNFORMATTED = 1,
+    NOT_INSERTED = 2,
+    CARD_DAMAGED = 3,
+    CARD_LOCKED = 10,
+    SLOW_CARD = 11,
+    FORMAT_REQUIRED = 12,
+    FORMATTING = 13,
+    END = 99
+};
+enum class LockVideoStatus
+{
+    UNLOCK = 0,
+    LOCK,
+    END
+};
+enum class StorageType
+{
+    EMMC = 0,
+    SD_CARD_1,
+    SD_CARD_2,
+    END
+};
+enum class PlayBackEvent
+{
+    START = 0,
+    STOP,
+    END
+};
+enum class StorageFileType
+{
+    PICTURE = 1,
+    VIDEO,
+    END
+};
+enum class StorageFileEvent
+{
+    LOOP = 0,
+    PIR,
+    CRASH,
+    EMR,
+    EVENT,
+    PARK,
+    END
+};
+enum class SwitchStatus
+{
+    OFF = 0,
+    ON,
+    END
+};
+enum class GpsCapability
+{
+    NOT_SUPPORT = 0,
+    END
+};
+enum class DeviceType
+{
+    DASH_CAMERA = 0,
+    END
+};
+enum class DashAlbum
+{
+    SUPPORT_PARKING_MONITOR_ALBUM = 0,
+    NOT_SUPPORT_PARKING_MONITOR_ALBUM,
+    END
+};
+enum class AppLock
+{
+    NOT_SUPPORT_APP_LOCK = 0,
+    SUPPORT_APP_LOCK,
+    END
+};
+enum class DeleteLock
+{
+    SUPPORT_DELETE_LOCK = 0,
+    NOT_SUPPORT_DELETE_LOCK,
+    END
+};
+enum class DeviceMode
+{
+    NEED_TO_SWITCH = 0,
+    NOT_NEED_TO_SWITCH,
+    END
+};
+enum class PlaybackType
+{
+    DOWNLOAD_PLAYBACK = 0,
+    RTSP_TCP,
+    RTSP_UDP,
+    END
+};
+enum class PhotographCapability
+{
+    SUPPORT_TAKE_PICTURE = 0,
+    NOT_SUPPORT_TAKE_PICTURE,
+    END
+};
+enum class WifiCapability
+{
+    SUPPORT_MODIFY_SSID_AND_PASSWORD = 0,
+    ONLY_SUPPORT_MODIFY_PASSWORD,
+    NOLY_SUPPORT_MODIFY_SSID,
+    NOT_SUPPORT_MODIFY_ANYTHING,
+    END
+};
+enum class FileCopy
+{
+    NOT_SUPPORT_COPY = 0,
+    SUPPORT_COPY,
+    END
+};
+enum class RecordingStatus
+{
+    RECORDING_STOP = 0,
+    RECORDING_START,
+    END
+};
+enum class MicrophoneStatus
+{
+    OFF = 0,
+    ON,
+    END
+};
+enum class BatteryStatus
+{
+    CHARGING = 0,
+    NOT_CHARGING,
+    END
+};
+typedef struct app_get_product_info
+{
+    app_get_product_info();
+    std::string mModel;
+    std::string mCompany;
+    std::string mSoc;
+    std::string mSp;
+} AppGetProductInfo;
+typedef struct app_get_device_attr
+{
+    app_get_device_attr();
+    std::string mUUID;
+    std::string mSoftVersion;
+    std::string mOtaVersion;
+    std::string mHardwareVersion;
+    std::string mSSID;
+    std::string mBSSID;
+    std::string mCameraNumber;
+    std::string mCurrentCameraID;
+    std::string mWifiReboot;
+} AppGetDeviceAttr;
+typedef struct app_get_media_info
+{
+    app_get_media_info();
+    std::string mRtspUrl;
+    std::string mTransport;
+    int mPort; ///< The port number of TCP, which the APP will use to initiate TCP connections to the device (server).
+} AppGetMediaInfo;
+typedef struct app_get_sd_card_info
+{
+    app_get_sd_card_info();
+    SdCardStatus mStatus;
+    unsigned long long mFree;
+    unsigned long long mTotal;
+} AppGetSdCardInfo;
+typedef struct app_get_battery_info
+{
+    app_get_battery_info();
+    int mCapacity;
+    ChargeStatus mChargeStatus;
+} AppGetBatteryInfo;
+typedef struct app_get_param_value
+{
+    app_get_param_value();
+    SwitchStatus mMicStatus;
+    SwitchStatus mRec;
+} AppParamValue;
+typedef struct app_get_capability
+{
+    app_get_capability();
+    GpsCapability mGpsCapability;
+    DeviceType mDeviceType;
+    DashAlbum mAlbum;
+    AppLock mAppLock;
+    DeleteLock mDeleteLock;
+    DeviceMode mDeviceMode;
+    PlaybackType mPlaybackType;
+    PhotographCapability mPhotographCapability;
+    WifiCapability mWifiCapability;
+    FileCopy mFileCopy;
+} AppGetCapability;
+typedef struct app_get_storage_info
+{
+    app_get_storage_info();
+    int mIndex;
+    StorageType mType;
+    std::string mName;
+    unsigned long long mFree;
+    unsigned long long mTotal;
+} AppGetStorageInfo;
+typedef struct app_get_file_info
+{
+    app_get_file_info();
+    int mStartIndex;
+    int mStopIndex;
+    StorageFileEvent mEvent;
+} AppGetFileInfo;
+typedef struct app_get_file_list
+{
+    app_get_file_list();
+    std::string mName;
+    int mDuration;
+    int mSize;
+    time_t mCreateTime_s;
+    StorageFileType mType;
+} AppGetFileList;
+typedef struct app_set_param_value
+{
+    app_set_param_value();
+    std::string mName;
+    int mValue;
+} AppSetParamValue;
+typedef struct app_set_date_time
+{
+    app_set_date_time(const unsigned int year, const unsigned int month, const unsigned int day,
+                      const unsigned int hour, const unsigned int minute, const unsigned int second);
+    const unsigned int mYear;
+    const unsigned int mMonth;
+    const unsigned int mDay;
+    const unsigned int mHour;
+    const unsigned int mMinute;
+    const unsigned int mSecond;
+} AppSetDateTime;
+typedef struct app_upload_file
+{
+    app_upload_file(const std::string filePath, const UploadCommand command);
+    const std::string mFilePath;
+    const UploadCommand mCommand;
+    ResposeResult mResult;
+} AppUploadFile;
+typedef struct app_get_thumbnail
+{
+    app_get_thumbnail(const std::string file);
+    const std::string mFile;
+    std::string mThumbnail;
+} AppGetThumbnail;
+typedef struct app_param
+{
+    app_param(const char *ip, const int &httpPort, const int &tcpPort);
+    const char *mIP;
+    const int mHttpPort;
+    const int mTcpPort;
+} AppParam;
+class VAppClient
+{
+public:
+    VAppClient() = default;
+    virtual ~VAppClient() = default;
+    virtual void SetRecordingStatus(const RecordingStatus &status);
+    virtual void SetMicrophoneStatus(const MicrophoneStatus &status);
+    virtual void SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity);
+    virtual void SetSdCardStatus(const SdCardStatus &status);
+    virtual void DeletedFileMessage(const std::string &file, const StorageFileType &type);
+    virtual void CreatedFileMessage(const std::string &file, const StorageFileType &type);
+};
+class VAppMonitor
+{
+public:
+    VAppMonitor() = default;
+    virtual ~VAppMonitor() = default;
+    virtual StatusCode GetProductInfo(AppGetProductInfo &param);
+    virtual StatusCode GetDeviceAttr(AppGetDeviceAttr &param);
+    virtual StatusCode GetMediaInfo(AppGetMediaInfo &param);
+    virtual StatusCode GetSdCardInfo(AppGetSdCardInfo &param);
+    virtual StatusCode GetBatteryInfo(AppGetBatteryInfo &param);
+    virtual StatusCode GetParamValue(AppParamValue &param);
+    virtual StatusCode GetCapability(AppGetCapability &param);
+    virtual StatusCode GetLockVideoStatus(LockVideoStatus &param);
+    virtual StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param);
+    virtual StatusCode GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param);
+    virtual StatusCode SetDateTime(const AppSetDateTime &param);
+    virtual StatusCode SetTimeZone(const unsigned int &zone);
+    virtual StatusCode SetParamValue(const AppSetParamValue &param);
+    virtual StatusCode EnterRecorder(void);
+    virtual StatusCode AppPlayback(const PlayBackEvent &event);
+    virtual StatusCode UploadFile(AppUploadFile &param);
+    virtual StatusCode GetThumbnail(AppGetThumbnail &param);
+    virtual StatusCode AppClientConnected(std::shared_ptr<VAppClient> &client);
+};
+class IAppManager
+{
+public:
+    IAppManager() = default;
+    virtual ~IAppManager() = default;
+    static std::shared_ptr<IAppManager> &GetInstance(std::shared_ptr<IAppManager> *impl = nullptr);
+    virtual const StatusCode Init(const AppParam &param);
+    virtual const StatusCode UnInit(void);
+    virtual const StatusCode SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor);
+    virtual StatusCode SetSdCardStatus(const SdCardStatus &status);
+};
+#endif

middleware/AppManager/src/AppClient.cpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "AppClient.h"
+#include "IAppProtocolHandle.h"
+#include "ILog.h"
+#include "TcpModule.h"
+AppClient::AppClient(const void *clientObject) : mClientObject(clientObject)
+{
+}
+void AppClient::SetRecordingStatus(const RecordingStatus &status)
+{
+    std::shared_ptr<ProtocolPacket> packet = IAppProtocolHandle::GetInstance()->SetRecordingStatus(status);
+    AcceptClientWrite((void *)mClientObject, packet->mData, packet->mDataLength);
+}
+void AppClient::SetMicrophoneStatus(const MicrophoneStatus &status)
+{
+    std::shared_ptr<ProtocolPacket> packet = IAppProtocolHandle::GetInstance()->SetMicrophoneStatus(status);
+    AcceptClientWrite((void *)mClientObject, packet->mData, packet->mDataLength);
+}
+void AppClient::SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity)
+{
+    std::shared_ptr<ProtocolPacket> packet =
+        IAppProtocolHandle::GetInstance()->SetBatteryStatus(status, batteryCapacity);
+    AcceptClientWrite((void *)mClientObject, packet->mData, packet->mDataLength);
+}
+void AppClient::SetSdCardStatus(const SdCardStatus &status)
+{
+    std::shared_ptr<ProtocolPacket> packet = IAppProtocolHandle::GetInstance()->SetSdCardStatus(status);
+    LogInfo("AppClient::SetSdCardStatus: \n%s\n", (const char *)packet->mData);
+    AcceptClientWrite((void *)mClientObject, packet->mData, packet->mDataLength);
+}
+void AppClient::DeletedFileMessage(const std::string &file, const StorageFileType &type)
+{
+    std::shared_ptr<ProtocolPacket> packet = IAppProtocolHandle::GetInstance()->DeletedFileMessage(file, type);
+    AcceptClientWrite((void *)mClientObject, packet->mData, packet->mDataLength);
+}
+void AppClient::CreatedFileMessage(const std::string &file, const StorageFileType &type)
+{
+    std::shared_ptr<ProtocolPacket> packet = IAppProtocolHandle::GetInstance()->CreatedFileMessage(file, type);
+    AcceptClientWrite((void *)mClientObject, packet->mData, packet->mDataLength);
+}

middleware/AppManager/src/AppClient.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef APP_CLIENT_H
+#define APP_CLIENT_H
+#include "IAppManager.h"
+class AppClient : public VAppClient
+{
+public:
+    AppClient(const void *clientObject);
+    virtual ~AppClient() = default;
+    void SetRecordingStatus(const RecordingStatus &status) override;
+    void SetMicrophoneStatus(const MicrophoneStatus &status) override;
+    void SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity) override;
+    void SetSdCardStatus(const SdCardStatus &status) override;
+    void DeletedFileMessage(const std::string &file, const StorageFileType &type) override;
+    void CreatedFileMessage(const std::string &file, const StorageFileType &type) override;
+
+private:
+    const void *mClientObject;
+};
+#endif

middleware/AppManager/src/AppManager.cpp

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "AppManager.h"
+#include "AppClient.h"
+#include "AppManagerMakePtr.h"
+#include "IHalCpp.h"
+#include "ILog.h"
+#include "TcpModule.h"
+#include "WebServer.h"
+AppManager::AppManager() : mTcpServer(nullptr), mInitRuning(false)
+{
+}
+const StatusCode AppManager::Init(const AppParam &param)
+{
+    std::shared_ptr<IAppProtocolHandle> protocolHandle;
+    AppManagerMakePtr::GetInstance()->CreateProtocolHandle(protocolHandle);
+    IAppProtocolHandle::GetInstance(&protocolHandle);
+    auto initThread = [](std::shared_ptr<AppManager> appManager, const AppParam param) {
+        LogInfo("WifiApModeInit started.\n");
+        appManager->WifiApModeInit(param);
+    };
+    mInitThread = std::thread(initThread, shared_from_this(), param);
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode AppManager::UnInit(void)
+{
+    if (true == mInitRuning) {
+        std::shared_ptr<VWifiHal> wifi;
+        IHalCpp::GetInstance()->GetWifiHal(wifi);
+        if (!wifi) {
+            LogWarning("Get wifi hal failed.\n");
+            goto GOAHEAD;
+        }
+        wifi->CloseApMode();
+    }
+GOAHEAD:
+    mInitRuning = false;
+    if (mInitThread.joinable()) {
+        mInitThread.join();
+    }
+    HttpServerStop();
+    TcpServerStop();
+    std::shared_ptr<IAppProtocolHandle> protocolHandle = std::make_shared<IAppProtocolHandle>();
+    IAppProtocolHandle::GetInstance(&protocolHandle);
+    mAppMonitor.reset();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode AppManager::SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor)
+{
+    IAppProtocolHandle::GetInstance()->SetAppMonitor(monitor);
+    mAppMonitor = monitor;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode AppManager::SetSdCardStatus(const SdCardStatus &status)
+{
+    for (const auto &pair : mAppClients) {
+        pair.second->SetSdCardStatus(status);
+    }
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void AppManager::AppRequestHandle(const char *url, const unsigned int urlLength, ResponseHandle responseHandle,
+                                  void *context)
+{
+    IAppProtocolHandle::GetInstance()->RequestHandle(url, urlLength, responseHandle, context);
+}
+void AppManager::AppRequestHandleTcp(const char *data, const unsigned int dataLength, ResponseHandle responseHandle,
+                                     void *context)
+{
+}
+void AppManager::AppClientConnected(const void *client, const char *ip)
+{
+    void *object = (void *)client;
+    mAppClients[object] = std::make_shared<AppClient>(client);
+    mAppMonitor->AppClientConnected(mAppClients[object]);
+}
+void AppManager::AppClientClosed(const void *client)
+{
+    void *object = (void *)client;
+    auto it = mAppClients.find(object);
+    if (it != mAppClients.end()) {
+        mAppClients.erase(it);
+    }
+    else {
+        LogError("App client not exit.\n");
+    }
+}
+void AppManager::HttpServerStart(const AppParam &param)
+{
+    auto httpServerThread = [=](std::shared_ptr<AppManager> app) {
+        LogInfo("AppManager httpServer started.\n");
+        app->HttpServerThread(param);
+    };
+    mHttpSever = std::thread(httpServerThread, shared_from_this());
+}
+void AppManager::HttpServerStop(void)
+{
+    WebServerExit();
+    if (mHttpSever.joinable()) {
+        mHttpSever.join();
+    }
+}
+void AppManager::HttpServerThread(const AppParam &param)
+{
+    std::shared_ptr<AppManager> app = shared_from_this();
+    auto httpHandle =
+        [](const char *url, const unsigned int urlLength, ResponseHandle responseHandle, void *context) -> void {
+        // LogInfo("url = %s\n", url);
+        std::shared_ptr<IAppManager> app = IAppManager::GetInstance();
+        std::shared_ptr<AppManager> appImpl = std::dynamic_pointer_cast<AppManager>(app);
+        if (appImpl) {
+            appImpl->AppRequestHandle(url, urlLength, responseHandle, context);
+        }
+    };
+    WebServerParam web = {.mIp = param.mIP, .mPort = param.mHttpPort, .mHttpRequestHandle = httpHandle};
+    WebServerInit(web);
+    WebServerUnInit();
+}
+void AppManager::TcpServerStart(const AppParam &param)
+{
+    auto acceptClientFunc = [](void *object, const char *ip) -> bool {
+        LogInfo("accept client, peer ip: %s\n", ip);
+        if (nullptr != object) {
+            std::shared_ptr<IAppManager> app = IAppManager::GetInstance();
+            std::shared_ptr<AppManager> appImpl = std::dynamic_pointer_cast<AppManager>(app);
+            if (appImpl) {
+                appImpl->AppClientConnected(object, ip);
+            }
+            return true;
+        }
+        return false;
+    };
+    auto readFunc = [](const void *data, const ssize_t len, const void *object) -> void {
+        LogInfo("read data: %s\n", (char *)data);
+    };
+    auto closedFunc = [](const void *object) -> void {
+        LogInfo("closed.\n");
+        std::shared_ptr<IAppManager> app = IAppManager::GetInstance();
+        std::shared_ptr<AppManager> appImpl = std::dynamic_pointer_cast<AppManager>(app);
+        if (appImpl) {
+            appImpl->AppClientClosed(object);
+        }
+    };
+    TcpServerParam tcpServerparam = {
+        .mIp = param.mIP,
+        .mPort = param.mTcpPort,
+        .mAcceptClientFunc = acceptClientFunc,
+        .mClientAcceptParam =
+            {
+                .mReadFunc = readFunc,
+                .mClosedFunc = closedFunc,
+            },
+    };
+    mTcpServer = CreateTcpServer(tcpServerparam);
+    if (nullptr == mTcpServer) {
+        LogError("Create tcp server failed.\n");
+    }
+    LogInfo("Create tcp server success.\n");
+}
+void AppManager::TcpServerStop(void)
+{
+    if (nullptr != mTcpServer) {
+        FreeTcpServer(mTcpServer);
+    }
+}
+void AppManager::WifiApModeInit(const AppParam &param)
+{
+    mInitRuning = true;
+    std::shared_ptr<VWifiHal> wifi;
+    IHalCpp::GetInstance()->GetWifiHal(wifi);
+    if (!wifi) {
+        LogError("Get wifi hal failed.\n");
+        return;
+    }
+    StatusCode codePower = wifi->PowerOn();
+    if (!IsCodeOK(codePower)) {
+        LogError("Wifi power on failed.\n");
+        return;
+    }
+    /**
+     * @brief This interface depends on hardware and may block. It is necessary to ensure that hardware interface
+     * blocking does not cause the main thread to block.
+     */
+    StatusCode code = wifi->OpenApMode();
+    if (!IsCodeOK(code)) {
+        LogError("OpenApMode failed.\n");
+        return;
+    }
+    if (false == mInitRuning) {
+        LogWarning("AppManager init stop.\n");
+        return;
+    }
+    HttpServerStart(param);
+    TcpServerStart(param);
+}

middleware/AppManager/src/AppManager.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef APP_MANAGER_H
+#define APP_MANAGER_H
+#include "IAppManager.h"
+#include "IAppProtocolHandle.h"
+#include <map>
+#include <thread>
+class AppManager : public IAppManager, public std::enable_shared_from_this<AppManager>
+{
+public:
+    AppManager();
+    virtual ~AppManager() = default;
+    const StatusCode Init(const AppParam &param) override;
+    const StatusCode UnInit(void) override;
+    const StatusCode SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor) override;
+    StatusCode SetSdCardStatus(const SdCardStatus &status) override;
+    void AppRequestHandle(const char *url, const unsigned int urlLength, ResponseHandle responseHandle, void *context);
+    void AppRequestHandleTcp(const char *data, const unsigned int dataLength, ResponseHandle responseHandle,
+                             void *context);
+    void AppClientConnected(const void *client, const char *ip);
+    void AppClientClosed(const void *client);
+
+private:
+    void HttpServerStart(const AppParam &param);
+    void HttpServerStop(void);
+    void HttpServerThread(const AppParam &param);
+
+private:
+    void TcpServerStart(const AppParam &param);
+    void TcpServerStop(void);
+
+private:
+    void WifiApModeInit(const AppParam &param);
+
+private:
+    std::thread mHttpSever;
+    std::shared_ptr<IAppProtocolHandle> mProtocolHandle;
+    void *mTcpServer;
+    std::shared_ptr<VAppMonitor> mAppMonitor;
+    std::map<void *, std::shared_ptr<VAppClient>> mAppClients;
+    bool mInitRuning;
+    std::thread mInitThread;
+};
+
+#endif

middleware/AppManager/src/AppManagerMakePtr.cpp

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "AppManagerMakePtr.h"
+#include "AppManager.h"
+#include "ILog.h"
+// extern bool CreateProtocolHandleImpl();
+bool CreateAppManagerModule(void)
+{
+    // CreateProtocolHandleImpl(); // TODO: not good for gtest.
+    auto instance = std::make_shared<IAppManager>();
+    StatusCode code = AppManagerMakePtr::GetInstance()->CreateAppManager(instance);
+    if (IsCodeOK(code)) {
+        LogInfo("CreateAppManager is ok.\n");
+        IAppManager::GetInstance(&instance);
+        return true;
+    }
+    return false;
+}
+bool DestroyAppManagerModule(void)
+{
+    auto instance = std::make_shared<IAppManager>();
+    IAppManager::GetInstance(&instance);
+    return true;
+}
+std::shared_ptr<AppManagerMakePtr> &AppManagerMakePtr::GetInstance(std::shared_ptr<AppManagerMakePtr> *impl)
+{
+    static auto instance = std::make_shared<AppManagerMakePtr>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+const StatusCode AppManagerMakePtr::CreateAppManager(std::shared_ptr<IAppManager> &impl)
+{
+    LogInfo("AppManagerMakePtr::CreateAppManager.\n");
+    auto tmp = std::make_shared<AppManager>();
+    impl = tmp;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode AppManagerMakePtr::CreateProtocolHandle(std::shared_ptr<IAppProtocolHandle> &impl)
+{
+    auto tmp = std::make_shared<IAppProtocolHandle>();
+    impl = tmp;
+    return CreateStatusCode(STATUS_CODE_OK);
+}

middleware/AppManager/src/AppManagerMakePtr.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DEVICE_MANAGER_MAKE_PTR_H
+#define DEVICE_MANAGER_MAKE_PTR_H
+#include "IAppManager.h"
+#include "IAppProtocolHandle.h"
+#include "StatusCode.h"
+#include <memory>
+class AppManagerMakePtr
+{
+public:
+    AppManagerMakePtr() = default;
+    virtual ~AppManagerMakePtr() = default;
+    static std::shared_ptr<AppManagerMakePtr> &GetInstance(std::shared_ptr<AppManagerMakePtr> *impl = nullptr);
+    virtual const StatusCode CreateAppManager(std::shared_ptr<IAppManager> &impl);
+    virtual const StatusCode CreateProtocolHandle(std::shared_ptr<IAppProtocolHandle> &impl);
+};
+#endif

middleware/AppManager/src/IAppManager.cpp

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "IAppManager.h"
+#include "ILog.h"
+app_get_product_info::app_get_product_info()
+{
+}
+app_get_device_attr::app_get_device_attr()
+{
+}
+app_get_media_info::app_get_media_info()
+{
+    mPort = -1;
+}
+app_get_sd_card_info::app_get_sd_card_info()
+{
+    mStatus = SdCardStatus::END;
+    mFree = 0;
+    mTotal = 0;
+}
+app_get_battery_info::app_get_battery_info()
+{
+    mCapacity = 0;
+    mChargeStatus = ChargeStatus::END;
+}
+app_get_param_value::app_get_param_value()
+{
+    mRec = SwitchStatus::END;
+    mMicStatus = SwitchStatus::END;
+}
+app_get_capability::app_get_capability()
+{
+    mGpsCapability = GpsCapability::END;
+    mDeviceType = DeviceType::END;
+    mAlbum = DashAlbum::END;
+    mAppLock = AppLock::END;
+    mDeleteLock = DeleteLock::END;
+    mDeviceMode = DeviceMode::END;
+    mPlaybackType = PlaybackType::END;
+    mPhotographCapability = PhotographCapability::END;
+    mWifiCapability = WifiCapability::END;
+    mFileCopy = FileCopy::END;
+}
+app_get_storage_info::app_get_storage_info()
+{
+    mIndex = -1;
+    mType = StorageType::END;
+    mFree = 0;
+    mTotal = 0;
+}
+app_get_file_info::app_get_file_info()
+{
+    mStartIndex = 0;
+    mStopIndex = 0;
+    mEvent = StorageFileEvent::END;
+}
+app_get_file_list::app_get_file_list()
+{
+    mDuration = 0;
+    mSize = 0;
+    mCreateTime_s = 0;
+    mType = StorageFileType::END;
+}
+app_set_param_value::app_set_param_value()
+{
+    mValue = -1;
+}
+app_set_date_time::app_set_date_time(const unsigned int year, const unsigned int month, const unsigned int day,
+                                     const unsigned int hour, const unsigned int minute, const unsigned int second)
+    : mYear(year), mMonth(month), mDay(day), mHour(hour), mMinute(minute), mSecond(second)
+{
+}
+app_upload_file::app_upload_file(const std::string filePath, const UploadCommand command)
+    : mFilePath(filePath), mCommand(command)
+{
+    mResult = ResposeResult::END;
+}
+app_get_thumbnail::app_get_thumbnail(const std::string file) : mFile(file)
+{
+}
+app_param::app_param(const char *ip, const int &httpPort, const int &tcpPort)
+    : mIP(ip), mHttpPort(httpPort), mTcpPort(tcpPort)
+{
+}
+void VAppClient::SetRecordingStatus(const RecordingStatus &status)
+{
+}
+void VAppClient::SetMicrophoneStatus(const MicrophoneStatus &status)
+{
+}
+void VAppClient::SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity)
+{
+}
+void VAppClient::SetSdCardStatus(const SdCardStatus &status)
+{
+}
+void VAppClient::DeletedFileMessage(const std::string &file, const StorageFileType &type)
+{
+}
+void VAppClient::CreatedFileMessage(const std::string &file, const StorageFileType &type)
+{
+}
+StatusCode VAppMonitor::GetProductInfo(AppGetProductInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetDeviceAttr(AppGetDeviceAttr &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetMediaInfo(AppGetMediaInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetSdCardInfo(AppGetSdCardInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetParamValue(AppParamValue &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetCapability(AppGetCapability &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetLockVideoStatus(LockVideoStatus &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetStorageInfo(std::vector<AppGetStorageInfo> &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::SetDateTime(const AppSetDateTime &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::SetTimeZone(const unsigned int &zone)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::SetParamValue(const AppSetParamValue &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::EnterRecorder(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::AppPlayback(const PlayBackEvent &event)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::UploadFile(AppUploadFile &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::GetThumbnail(AppGetThumbnail &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::AppClientConnected(std::shared_ptr<VAppClient> &client)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+std::shared_ptr<IAppManager> &IAppManager::GetInstance(std::shared_ptr<IAppManager> *impl)
+{
+    static auto instance = std::make_shared<IAppManager>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+const StatusCode IAppManager::Init(const AppParam &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+const StatusCode IAppManager::UnInit(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+const StatusCode IAppManager::SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode IAppManager::SetSdCardStatus(const SdCardStatus &status)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}

middleware/AppManager/src/IAppProtocolHandle.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "IAppProtocolHandle.h"
+#include "ILog.h"
+protocol_packet::~protocol_packet()
+{
+    if (nullptr != mData) {
+        free(mData);
+        mData = nullptr;
+    }
+}
+std::shared_ptr<IAppProtocolHandle> &IAppProtocolHandle::GetInstance(std::shared_ptr<IAppProtocolHandle> *impl)
+{
+    static auto instance = std::make_shared<IAppProtocolHandle>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+void IAppProtocolHandle::Init(void)
+{
+}
+void IAppProtocolHandle::UnInit(void)
+{
+}
+void IAppProtocolHandle::RequestHandle(const char *url, const unsigned int &urlLength, ResponseHandle responseHandle,
+                                       void *context)
+{
+}
+void IAppProtocolHandle::RequestHandleTcp(const char *data, const unsigned int &dataLength,
+                                          ResponseHandle responseHandle, void *context)
+{
+}
+void IAppProtocolHandle::SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor)
+{
+}
+std::shared_ptr<ProtocolPacket> IAppProtocolHandle::SetRecordingStatus(const RecordingStatus &status)
+{
+    return std::make_shared<ProtocolPacket>();
+}
+std::shared_ptr<ProtocolPacket> IAppProtocolHandle::SetMicrophoneStatus(const MicrophoneStatus &status)
+{
+    return std::make_shared<ProtocolPacket>();
+}
+std::shared_ptr<ProtocolPacket> IAppProtocolHandle::SetBatteryStatus(const BatteryStatus &status,
+                                                                     const int &batteryCapacity)
+{
+    return std::make_shared<ProtocolPacket>();
+}
+std::shared_ptr<ProtocolPacket> IAppProtocolHandle::SetSdCardStatus(const SdCardStatus &status)
+{
+    return std::make_shared<ProtocolPacket>();
+}
+std::shared_ptr<ProtocolPacket> IAppProtocolHandle::DeletedFileMessage(const std::string &file,
+                                                                       const StorageFileType &type)
+{
+    return std::make_shared<ProtocolPacket>();
+}
+std::shared_ptr<ProtocolPacket> IAppProtocolHandle::CreatedFileMessage(const std::string &file,
+                                                                       const StorageFileType &type)
+{
+    return std::make_shared<ProtocolPacket>();
+}

middleware/AppManager/src/IAppProtocolHandle.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef I_APP_PROTOCOL_HANDLE_H
+#define I_APP_PROTOCOL_HANDLE_H
+#include "IAppManager.h"
+#include "StatusCode.h"
+#include "WebServer.h"
+#include <iostream>
+#include <memory>
+#include <vector>
+typedef struct protocol_packet
+{
+    protocol_packet() : mData(nullptr), mDataLength(0)
+    {
+    }
+    protocol_packet(void *data, const size_t &size) : mData(data), mDataLength(size)
+    {
+    }
+    ~protocol_packet();
+    void *mData;
+    size_t mDataLength;
+} ProtocolPacket;
+class VAppDataPacket
+{
+public:
+    VAppDataPacket() = default;
+    virtual ~VAppDataPacket() = default;
+};
+class IAppProtocolHandle
+{
+public:
+    IAppProtocolHandle() = default;
+    virtual ~IAppProtocolHandle() = default;
+    static std::shared_ptr<IAppProtocolHandle> &GetInstance(std::shared_ptr<IAppProtocolHandle> *impl = nullptr);
+    virtual void Init(void);
+    virtual void UnInit(void);
+    virtual void RequestHandle(const char *url, const unsigned int &urlLength, ResponseHandle responseHandle,
+                               void *context);
+    virtual void RequestHandleTcp(const char *data, const unsigned int &dataLength, ResponseHandle responseHandle,
+                                  void *context);
+    virtual void SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor);
+    virtual std::shared_ptr<ProtocolPacket> SetRecordingStatus(const RecordingStatus &status);
+    virtual std::shared_ptr<ProtocolPacket> SetMicrophoneStatus(const MicrophoneStatus &status);
+    virtual std::shared_ptr<ProtocolPacket> SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity);
+    virtual std::shared_ptr<ProtocolPacket> SetSdCardStatus(const SdCardStatus &status);
+    virtual std::shared_ptr<ProtocolPacket> DeletedFileMessage(const std::string &file, const StorageFileType &type);
+    virtual std::shared_ptr<ProtocolPacket> CreatedFileMessage(const std::string &file, const StorageFileType &type);
+};
+#endif

middleware/AppManager/src/Protocol/README.md

@@ -0,0 +1,3 @@
+# 1. 协议目录说明
+
+   可配置选型不同的对接协议。

middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.h

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef SIX_FRAME_HANDLE_H
+#define SIX_FRAME_HANDLE_H
+#include "IAppManager.h"
+#include "IAppProtocolHandle.h"
+#include "StatusCode.h"
+#include <cJSON.h>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <vector>
+using ResquesHandleFunc = std::function<void(const std::string &, ResponseHandle, void *)>;
+class VParseUrl
+{
+public:
+    VParseUrl() = default;
+    virtual ~VParseUrl() = default;
+};
+using ParseUrlResultFunc = void(const std::string &, const std::string &, std::shared_ptr<VParseUrl> &);
+template <typename T>
+class ParseUrl : public VParseUrl
+{
+
+public:
+    ParseUrl()
+    {
+    }
+    virtual ~ParseUrl() = default;
+
+public:
+    T mData;
+};
+class SixFrameHandle : public IAppProtocolHandle
+{
+public:
+    SixFrameHandle();
+    virtual ~SixFrameHandle() = default;
+    // virtual void Init(void) {}
+    // virtual void UnInit(void) {}
+    void RequestHandle(const char *url, const unsigned int &urlLength, ResponseHandle responseHandle,
+                       void *context) override;
+    void RequestHandleTcp(const char *data, const unsigned int &dataLength, ResponseHandle responseHandle,
+                          void *context) override;
+
+private:
+    void ExtractParamsFromUrl(const std::string &url, ParseUrlResultFunc resultHandle,
+                              std::shared_ptr<VParseUrl> &context);
+    void RequestHandle2(const std::string command, const std::string &url, ResponseHandle responseHandle,
+                        void *context);
+    void DoNothing(const std::string &url, ResponseHandle responseHandle, void *context);
+    void RequestGetProductInfo(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetProductInfo(cJSON *result, const AppGetProductInfo &param);
+    void RequestGetDeviceAttr(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetDeviceAttr(cJSON *result, const AppGetDeviceAttr &param);
+    void RequestGetMediaInfo(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetMediaInfo(cJSON *result, const AppGetMediaInfo &param);
+    void RequestGetSdCardInfo(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetSdCardInfo(cJSON *result, const AppGetSdCardInfo &param);
+    void RequestGetBatteryInfo(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetBatteryInfo(cJSON *result, const AppGetBatteryInfo &param);
+    /**
+     * @brief There are many parameters that need to be set for the content that the APP needs to obtain in the protocol
+     * package, The APP may retrieve all or some of the parameters.
+     * @param url [in]
+     * @param paramList [out]
+     */
+    void RequestParamValueParse(const std::string &url, std::map<std::string, bool> &paramList);
+    void RequestGetParamValue(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetParamValue(cJSON *result, const AppParamValue &param, const std::map<std::string, bool> &paramList);
+    void RequestGetParamItems(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetParamItems(cJSON *result, const AppGetCapability &param,
+                               const std::map<std::string, bool> &paramList);
+    void RequestGetCapability(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetCapability(cJSON *result, const AppGetCapability &param);
+    void RequestGetLockVideoStatus(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetLockVideoStatus(cJSON *result, const LockVideoStatus &param);
+    void RequestGetStorageInfo(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetStorageInfo(cJSON *result, const std::vector<AppGetStorageInfo> &param);
+    AppGetFileInfo RequestGetFileListParse(const std::string &url);
+    void RequestGetFileList(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetFileList(cJSON *result, const std::vector<AppGetFileList> &param, const AppGetFileInfo &fileInfo);
+    AppSetDateTime RequestSetDateTimeParse(const std::string &url);
+    void RequestSetDateTime(const std::string &url, ResponseHandle responseHandle, void *context);
+    int RequestSetTimeZoneParse(const std::string &url);
+    void RequestSetTimeZone(const std::string &url, ResponseHandle responseHandle, void *context);
+    AppSetParamValue RequestSetParamValueParse(const std::string &url);
+    void RequestSetParamValue(const std::string &url, ResponseHandle responseHandle, void *context);
+    PlayBackEvent RequestPlaybackParse(const std::string &url);
+    void RequestPlayback(const std::string &url, ResponseHandle responseHandle, void *context);
+    void RequestEnterRecorder(const std::string &url, ResponseHandle responseHandle, void *context);
+    void RequestUpload(const std::string &url, ResponseHandle responseHandle, void *context);
+    std::string RequestGetThumbnailParse(const std::string &url);
+    void RequestGetThumbnail(const std::string &url, ResponseHandle responseHandle, void *context);
+
+private:
+    void RequestTcpHandle2(const std::string command, const cJSON *const data, ResponseHandle responseHandle,
+                           void *context); // TODO: delete
+    std::shared_ptr<ProtocolPacket> SetRecordingStatus(const RecordingStatus &status) override;
+    std::shared_ptr<ProtocolPacket> SetMicrophoneStatus(const MicrophoneStatus &status) override;
+    std::shared_ptr<ProtocolPacket> SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity) override;
+    std::shared_ptr<ProtocolPacket> SetSdCardStatus(const SdCardStatus &status) override;
+    std::shared_ptr<ProtocolPacket> DeletedFileMessage(const std::string &file, const StorageFileType &type) override;
+    std::shared_ptr<ProtocolPacket> CreatedFileMessage(const std::string &file, const StorageFileType &type) override;
+
+private:
+    cJSON *MakeResponseResult(const ResposeResult result, const bool requestSet = false);
+    void ResponseJsonString(cJSON *json, ResponseHandle responseHandle, void *context);
+    const char *PrintfFileEvent(const AppGetFileInfo &fileInfo);
+    void AddTimestamp(cJSON *json);
+    std::shared_ptr<ProtocolPacket> MakePacket(const cJSON *json);
+
+protected:
+    void SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor) override;
+
+private:
+    std::map<std::string, ResquesHandleFunc> mResquesHandleFunc;
+    std::shared_ptr<VAppMonitor> mAppMonitor;
+};
+#endif

middleware/AppManager/src/Protocol/SixFrame/SixFrameMakePtr.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "SixFrameMakePtr.h"
+#include "ILog.h"
+#include "SixFrameHandle.h"
+bool CreateProtocolHandleImpl(void)
+{
+    LogInfo("CreateProtocolHandleImpl SixFrameMakePtr.\n");
+    std::shared_ptr<AppManagerMakePtr> instance = std::make_shared<SixFrameMakePtr>();
+    AppManagerMakePtr::GetInstance(&instance);
+    return true;
+}
+const StatusCode SixFrameMakePtr::CreateProtocolHandle(std::shared_ptr<IAppProtocolHandle> &impl)
+{
+    auto tmp = std::make_shared<SixFrameHandle>();
+    impl = tmp;
+    return CreateStatusCode(STATUS_CODE_OK);
+}

middleware/AppManager/src/Protocol/SixFrame/SixFrameMakePtr.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef SIX_FRAME_MAKE_PTR_H
+#define SIX_FRAME_MAKE_PTR_H
+#include "AppManagerMakePtr.h"
+#include "IAppManager.h"
+#include "StatusCode.h"
+#include <memory>
+bool CreateProtocolHandleImpl(void);
+class SixFrameMakePtr : public AppManagerMakePtr
+{
+public:
+    SixFrameMakePtr() = default;
+    virtual ~SixFrameMakePtr() = default;
+    const StatusCode CreateProtocolHandle(std::shared_ptr<IAppProtocolHandle> &impl) override;
+};
+#endif

middleware/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_subdirectory(StateMachine)
+add_subdirectory(IpcConfig)
+add_subdirectory(DeviceManager)
+add_subdirectory(McuManager)
+add_subdirectory(McuAskBase)
+add_subdirectory(MediaManager)
+add_subdirectory(AppManager)
+add_subdirectory(StorageManager)
+add_subdirectory(FilesManager)
+add_subdirectory(HuntingUpgrade)

middleware/DeviceManager/CMakeLists.txt

@@ -0,0 +1,57 @@
+
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+include_directories(
+    ./src
+    ./include
+    ${UTILS_SOURCE_PATH}/StatusCode/include
+    ${UTILS_SOURCE_PATH}/Log/include
+    ${UTILS_SOURCE_PATH}/LedControl/include
+    ${HAL_SOURCE_PATH}/include
+)
+#do not rely on any other library
+#link_directories(
+#)
+
+aux_source_directory(./src SRC_FILES)
+
+set(TARGET_NAME DeviceManager)
+add_library(${TARGET_NAME} STATIC ${SRC_FILES})
+
+target_link_libraries(${TARGET_NAME} LedControl Hal StatusCode Log)
+
+if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
+add_custom_target(
+    DeviceManager_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${SRC_FILES}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/DeviceManager
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    DeviceManager_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${SRC_FILES} ${HEADER_FILES}
+    WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/DeviceManager
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make DeviceManager_code_check
+    COMMAND make DeviceManager_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()
+
+define_file_name(${TARGET_NAME})
+
+file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
+install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

middleware/DeviceManager/include/IDeviceManager.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef IDEVICEMANAGER_H
+#define IDEVICEMANAGER_H
+#include "StatusCode.h"
+#include <iostream>
+#include <memory>
+#include <vector>
+bool CreateDeviceManagerModule(void);
+bool DestroyDeviceManagerModule(void);
+using VirtualLedState = unsigned char;
+using VirtualKeyEvent = unsigned char;
+typedef struct key_status
+{
+    key_status(const VirtualKeyEvent &keyEvent, const long int holdTimeMs)
+        : mKeyEvent(keyEvent), mHoldTimeMs(holdTimeMs)
+    {
+    }
+    const VirtualKeyEvent mKeyEvent;
+    const long int mHoldTimeMs;
+} KeyStatus;
+class VKeyMonitor
+{
+public:
+    VKeyMonitor() = default;
+    virtual ~VKeyMonitor() = default;
+    virtual void KeyEventReport(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs);
+};
+class LedControlContext
+{
+public:
+    LedControlContext() = default;
+    virtual ~LedControlContext() = default;
+};
+class IDeviceManager
+{
+public:
+    IDeviceManager() = default;
+    virtual ~IDeviceManager() = default;
+    static std::shared_ptr<IDeviceManager> &GetInstance(std::shared_ptr<IDeviceManager> *impl = nullptr);
+    virtual const StatusCode Init(void);
+    virtual const StatusCode UnInit(void);
+    virtual const StatusCode ControlLed(const std::string &ledName, std::shared_ptr<LedControlContext> &control);
+    virtual const StatusCode SetAllKeysMonitor(std::shared_ptr<VKeyMonitor> &monitor);
+};
+#endif

middleware/DeviceManager/src/DeviceManager.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "DeviceManager.h"
+#include "ILog.h"
+#include "KeyManager.h"
+#include "LedManager.h"
+#include <vector>
+const StatusCode DeviceManager::Init(void)
+{
+    KeyManager::GetInstance()->Init();
+    KeyManager::GetInstance()->StartTimer();
+    LedManager::GetInstance()->Init();
+    LedManager::GetInstance()->StartTimer();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode DeviceManager::UnInit(void)
+{
+    KeyManager::GetInstance()->UnInit();
+    LedManager::GetInstance()->UnInit();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+const StatusCode DeviceManager::SetAllKeysMonitor(std::shared_ptr<VKeyMonitor> &monitor)
+{
+    LogInfo("DeviceManager::SetAllKeysMonitor\n");
+    return KeyManager::GetInstance()->SetKeyMonitor(monitor);
+}
+const StatusCode DeviceManager::ControlLed(const std::string &ledName, std::shared_ptr<LedControlContext> &control)
+{
+    LedManager::GetInstance()->ControlLed(ledName, control);
+    return CreateStatusCode(STATUS_CODE_OK);
+}

middleware/DeviceManager/src/DeviceManager.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DEVICE_MANAGER_H
+#define DEVICE_MANAGER_H
+#include "IDeviceManager.h"
+// #include "LedManager.h"
+
+class DeviceManager : public IDeviceManager
+{
+public:
+    DeviceManager() = default;
+    virtual ~DeviceManager() = default;
+
+    const StatusCode Init(void) override;
+    const StatusCode UnInit(void) override;
+    const StatusCode SetAllKeysMonitor(std::shared_ptr<VKeyMonitor> &monitor) override;
+    const StatusCode ControlLed(const std::string &ledName, std::shared_ptr<LedControlContext> &control) override;
+
+private:
+    // std::vector<std::shared_ptr<LedManager>> mLedManagers;
+};
+
+#endif

middleware/DeviceManager/src/DeviceManagerMakePtr.cpp

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "DeviceManagerMakePtr.h"
+#include "DeviceManager.h"
+#include "ILog.h"
+bool CreateDeviceManagerModule(void)
+{
+    auto instance = std::make_shared<IDeviceManager>();
+    StatusCode code = DeviceManagerMakePtr::GetInstance()->CreateDeviceManager(instance);
+    if (IsCodeOK(code)) {
+        LogInfo("CreateDeviceManager is ok.\n");
+        IDeviceManager::GetInstance(&instance);
+        return true;
+    }
+    return false;
+}
+bool DestroyDeviceManagerModule(void)
+{
+    auto instance = std::make_shared<IDeviceManager>();
+    IDeviceManager::GetInstance()->UnInit();
+    IDeviceManager::GetInstance(&instance);
+    return true;
+}
+std::shared_ptr<DeviceManagerMakePtr> &DeviceManagerMakePtr::GetInstance(std::shared_ptr<DeviceManagerMakePtr> *impl)
+{
+    static auto instance = std::make_shared<DeviceManagerMakePtr>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+const StatusCode DeviceManagerMakePtr::CreateDeviceManager(std::shared_ptr<IDeviceManager> &impl)
+{
+    auto tmp = std::make_shared<DeviceManager>();
+    impl = tmp;
+    return CreateStatusCode(STATUS_CODE_OK);
+}

middleware/DeviceManager/src/DeviceManagerMakePtr.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DEVICE_MANAGER_MAKE_PTR_H
+#define DEVICE_MANAGER_MAKE_PTR_H
+#include "IDeviceManager.h"
+#include "StatusCode.h"
+#include <memory>
+class DeviceManagerMakePtr
+{
+public:
+    DeviceManagerMakePtr() = default;
+    virtual ~DeviceManagerMakePtr() = default;
+    static std::shared_ptr<DeviceManagerMakePtr> &GetInstance(std::shared_ptr<DeviceManagerMakePtr> *impl = nullptr);
+    virtual const StatusCode CreateDeviceManager(std::shared_ptr<IDeviceManager> &impl);
+};
+#endif

middleware/DeviceManager/src/IDeviceManager.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "IDeviceManager.h"
+#include "ILog.h"
+void VKeyMonitor::KeyEventReport(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs)
+{
+}
+std::shared_ptr<IDeviceManager> &IDeviceManager::GetInstance(std::shared_ptr<IDeviceManager> *impl)
+{
+    static auto instance = std::make_shared<IDeviceManager>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+const StatusCode IDeviceManager::Init(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+const StatusCode IDeviceManager::UnInit(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+const StatusCode IDeviceManager::ControlLed(const std::string &ledName, std::shared_ptr<LedControlContext> &control)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+const StatusCode IDeviceManager::SetAllKeysMonitor(std::shared_ptr<VKeyMonitor> &monitor)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}

middleware/DeviceManager/src/KeyManager.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "KeyManager.h"
+#include "ILog.h"
+std::shared_ptr<KeyManager> &KeyManager::GetInstance(std::shared_ptr<KeyManager> *impl)
+{
+    static auto instance = std::make_shared<KeyManager>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+KeyManager::KeyManager()
+{
+}
+void KeyManager::Init(void)
+{
+    IHalCpp::GetInstance()->GetAllKeys(mAllKeyHal);
+}
+void KeyManager::UnInit(void)
+{
+    StopTimer();
+    mAllKeyHal.clear();
+}
+void KeyManager::StartTimer(void)
+{
+    if (mAllKeyHal.size() == 0) {
+        LogError("StartTimer failed, no key to manager.\n");
+        return;
+    }
+    SetKeyHalMonitor();
+    auto timerThread = [](std::shared_ptr<KeyManager> timer) {
+        LogInfo("Key timer started.\n");
+        timer->Timer();
+    };
+    mTimer = std::thread(timerThread, shared_from_this());
+}
+void KeyManager::StopTimer(void)
+{
+    mTimerRuning = false;
+    if (mTimer.joinable()) {
+        mTimer.join();
+    }
+}
+void KeyManager::Timer(void)
+{
+    LogInfo("Key timer started.\n");
+    mTimerRuning = true;
+    std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
+    while (mTimerRuning) {
+        for (iter = mAllKeyHal.begin(); iter != mAllKeyHal.end(); ++iter) {
+            std::shared_ptr<VKeyHal> keyHal = iter->second;
+            keyHal->CheckKeyStatus();
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(PERIPHERAL_CHECK_PERIOD_MS));
+    }
+}
+void KeyManager::GetAllKeysState(std::map<std::string, KeyStatus> &status)
+{
+    std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
+    for (iter = mAllKeyHal.begin(); iter != mAllKeyHal.end(); ++iter) {
+        std::shared_ptr<VKeyHal> keyHal = iter->second;
+        long int holdTimeMs = 0;
+        VirtualKeyEvent holdPressingEvent = 0x00;
+        keyHal->GetHoldPressingTimeMs(holdTimeMs, holdPressingEvent);
+        KeyStatus result(holdPressingEvent, holdTimeMs);
+        status.insert(std::make_pair(iter->first, result));
+    }
+}
+const StatusCode KeyManager::SetKeyMonitor(std::shared_ptr<VKeyMonitor> &monitor)
+{
+    mKeysMonitor = monitor;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void KeyManager::SetKeyHalMonitor(void)
+{
+    std::shared_ptr<VKeyHalMonitor> monitor = shared_from_this();
+    std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
+    for (iter = mAllKeyHal.begin(); iter != mAllKeyHal.end(); ++iter) {
+        std::shared_ptr<VKeyHal> keyHal = iter->second;
+        keyHal->SetKeyMonitor(monitor);
+    }
+}
+void KeyManager::KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event, const unsigned int &timeMs)
+{
+    auto monitor = mKeysMonitor.lock();
+    if (mKeysMonitor.expired()) {
+        LogError("monitor is nullptr.\n");
+        return;
+    }
+    // LogInfo("KeyEventHappened: key = %s, event = %d, time ms = %u\n", keyName.c_str(), event, timeMs);
+    monitor->KeyEventReport(keyName, static_cast<VirtualKeyEvent>(event), timeMs);
+}

middleware/DeviceManager/src/KeyManager.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef KEY_MANAGER_H
+#define KEY_MANAGER_H
+#include "IDeviceManager.h"
+#include "IHalCpp.h"
+#include <map>
+#include <memory>
+#include <mutex>
+#include <thread>
+class KeyManager : public VKeyHalMonitor, public std::enable_shared_from_this<KeyManager>
+{
+public:
+    KeyManager();
+    ~KeyManager() = default;
+    static std::shared_ptr<KeyManager> &GetInstance(std::shared_ptr<KeyManager> *impl = nullptr);
+    void Init(void);
+    void UnInit(void);
+    void StartTimer(void);
+    void StopTimer(void);
+    void GetAllKeysState(std::map<std::string, KeyStatus> &status);
+    const StatusCode SetKeyMonitor(std::shared_ptr<VKeyMonitor> &monitor);
+
+private:
+    void Timer(void);
+    void SetKeyHalMonitor(void);
+
+private:
+    void KeyEventHappened(const std::string &keyName, const VirtualKeyEvent &event,
+                          const unsigned int &timeMs) override;
+
+private:
+    std::mutex mMutex;
+    std::map<std::string, std::shared_ptr<VKeyHal>> mAllKeyHal;
+    bool mTimerRuning;
+    std::thread mTimer;
+    std::weak_ptr<VKeyMonitor> mKeysMonitor;
+};
+#endif

middleware/DeviceManager/src/LedManager.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "LedManager.h"
+#include "ILog.h"
+std::shared_ptr<LedManager> &LedManager::GetInstance(std::shared_ptr<LedManager> *impl)
+{
+    static auto instance = std::make_shared<LedManager>();
+    if (impl) {
+        if (instance.use_count() == 1) {
+            LogInfo("Instance changed succeed.\n");
+            instance = *impl;
+        }
+        else {
+            LogError("Can't changing the instance becase of using by some one.\n");
+        }
+    }
+    return instance;
+}
+void LedManager::Init(void)
+{
+    std::map<std::string, std::shared_ptr<VLedHal>> allLeds;
+    IHalCpp::GetInstance()->GetAllLeds(allLeds);
+    LedConversion(allLeds);
+}
+void LedManager::UnInit(void)
+{
+    StopTimer();
+    mMutex.lock();
+    for (auto &iter : mAllLedHal) {
+        iter.second->DeleteAllState();
+    }
+    mMutex.unlock();
+    mAllLedHal.clear();
+}
+void LedManager::Timer(void)
+{
+    mTimerRuning = true;
+    std::map<std::string, std::shared_ptr<VLedControl>>::iterator iter;
+    while (mTimerRuning) {
+        mMutex.lock();
+        for (iter = mAllLedHal.begin(); iter != mAllLedHal.end(); ++iter) {
+            std::shared_ptr<VLedControl> ledHal = iter->second;
+            ledHal->CheckState(LED_STATE_CHECK_PERIOD_MS);
+        }
+        mMutex.unlock();
+        std::this_thread::sleep_for(std::chrono::milliseconds(LED_STATE_CHECK_PERIOD_MS));
+    }
+}
+void LedManager::ControlLed(const std::string &ledName, std::shared_ptr<LedControlContext> &control)
+{
+    std::lock_guard<std::mutex> locker(mMutex);
+    std::shared_ptr<VSingleControl> singleControl = std::dynamic_pointer_cast<VSingleControl>(control);
+    if (!singleControl) {
+        LogError("led can't be controled.\n");
+        return;
+    }
+    auto iter = mAllLedHal.find(ledName);
+    if (iter == mAllLedHal.end()) {
+        LogError("Can't find led [%s].\n", ledName.c_str());
+        return;
+    }
+    mAllLedHal[ledName]->AddLedState(singleControl);
+}
+void LedManager::StartTimer(void)
+{
+    auto timerThread = [](std::shared_ptr<LedManager> timer) {
+        LogInfo("Led timer started.\n");
+        timer->Timer();
+    };
+    mTimer = std::thread(timerThread, shared_from_this());
+}
+void LedManager::StopTimer(void)
+{
+    mTimerRuning = false;
+    if (mTimer.joinable()) {
+        mTimer.join();
+    }
+}
+void LedManager::LedConversion(std::map<std::string, std::shared_ptr<VLedHal>> &ledHal)
+{
+    std::map<std::string, std::shared_ptr<VLedHal>>::iterator iter;
+    for (iter = ledHal.begin(); iter != ledHal.end(); ++iter) {
+        std::shared_ptr<VLedControl> led = std::dynamic_pointer_cast<VLedControl>(iter->second);
+        if (led) {
+            LogInfo("Get led [%s].\n", iter->first.c_str());
+            mAllLedHal[iter->first] = led;
+        }
+        else {
+            LogWarning("Missing something.\n");
+        }
+    }
+}

middleware/DeviceManager/src/LedManager.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef LED_MANAGER_H
+#define LED_MANAGER_H
+#include "IDeviceManager.h"
+#include "IHalCpp.h"
+#include "LedControl.h"
+#include <memory>
+#include <mutex>
+#include <thread>
+constexpr int LED_STATE_CHECK_PERIOD_MS = 100;
+class LedManager : public std::enable_shared_from_this<LedManager>
+{
+public:
+    LedManager() = default;
+    virtual ~LedManager() = default;
+    static std::shared_ptr<LedManager> &GetInstance(std::shared_ptr<LedManager> *impl = nullptr);
+    void Init(void);
+    void UnInit(void);
+    void StartTimer(void);
+    void StopTimer(void);
+    void ControlLed(const std::string &ledName, std::shared_ptr<LedControlContext> &control);
+
+private:
+    void Timer(void);
+    void LedConversion(std::map<std::string, std::shared_ptr<VLedHal>> &ledHal);
+
+private:
+    std::mutex mMutex;
+    std::map<std::string, std::shared_ptr<VLedControl>> mAllLedHal;
+    bool mTimerRuning;
+    std::thread mTimer;
+};
+#endif

middleware/FilesManager/CMakeLists.txt

@@ -0,0 +1,65 @@
+
+include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
+set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
+
+include_directories(
+    ./src
+    ./include
+    ${EXTERNAL_SOURCE_PATH}/sqlite3/sqlite-3430000
+    ${MIDDLEWARE_SOURCE_PATH}/StorageManager/include
+    ${UTILS_SOURCE_PATH}/StatusCode/include
+    ${UTILS_SOURCE_PATH}/Log/include
+    # ${UTILS_SOURCE_PATH}/UartDevice/include
+)
+#do not rely on any other library
+#link_directories(
+#)
+
+aux_source_directory(./src SRC_FILES)
+aux_source_directory(./src/sqlite3 SRC_FILES)
+
+set(TARGET_NAME FilesManager)
+add_library(${TARGET_NAME} STATIC ${SRC_FILES})
+
+target_link_libraries(${TARGET_NAME} sqlite3 StatusCode Log)
+
+if ("${COMPILE_IMPROVE_SUPPORT}" MATCHES "true")
+add_custom_target(
+    FilesManager_code_check
+    COMMAND ${CLANG_TIDY_EXE}
+    -checks='${CLANG_TIDY_CHECKS}'
+    --header-filter=.*
+    --system-headers=false
+    ${SRC_FILES}
+    ${CLANG_TIDY_CONFIG}
+    -p ${PLATFORM_PATH}/cmake-shell
+    WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/FilesManager
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make FilesManager_code_check
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+file(GLOB_RECURSE HEADER_FILES *.h)
+add_custom_target(
+    FilesManager_code_format
+    COMMAND ${CLANG_FORMAT_EXE}
+    -style=file
+    -i ${SRC_FILES}  ${HEADER_FILES}
+    WORKING_DIRECTORY ${MIDDLEWARE_SOURCE_PATH}/FilesManager
+)
+add_custom_command(
+    TARGET ${TARGET_NAME}
+    PRE_BUILD
+    COMMAND make FilesManager_code_check
+    COMMAND make FilesManager_code_format
+    WORKING_DIRECTORY ${PLATFORM_PATH}/cmake-shell/
+)
+endif()
+
+define_file_name(${TARGET_NAME})
+
+file(GLOB_RECURSE INSTALL_HEADER_FILES include/*.h)
+install(FILES ${INSTALL_HEADER_FILES} DESTINATION include)

middleware/FilesManager/README.md

@@ -0,0 +1,34 @@
+# 1. 文件管理
+
+## 1.1. 概述
+
+  IPC产品的文件管理模块。抓拍的图片或者视频的保存/删除/查询等操作通过该模块实现。
+
+## 1.2. 数据库管理设计
+
+  考虑到拓展性，使用数据库salite3对文件的各种属性进行管理。
+
+### 1.2.1. 数据库表
+
+## 1.3. 文件夹管理
+
+```
+DCIM/                       // 根目录
+├── picture                 // 图片目录
+│   └── 2024                // 年份记录
+│       ├── 01              // 月份记录
+│       │   └── xxx.jpg
+│       └── 02
+└── video                   // 视频目录
+    └── 2024                // 年份记录
+        └── 01              // 月份记录
+            └── xxx.MP4
+```
+
+## 1.4. 文件命名规则
+
+**文件类型**
+
+1. PIR抓拍；
+2. 定时抓拍；
+3. 手动抓拍；

middleware/FilesManager/include/IFilesManager.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef I_FILES_MANAGER_H
+#define I_FILES_MANAGER_H
+#include "StatusCode.h"
+#include <memory>
+typedef struct save_file_info
+{
+    save_file_info(const std::string &fileName);
+    const std::string mFileName;
+} SaveFileInfo;
+bool CreateFilesManagerModule(void);
+bool DestroyFilesManagerModule(void);
+class IFilesManager
+{
+public:
+    IFilesManager() = default;
+    virtual ~IFilesManager() = default;
+    static std::shared_ptr<IFilesManager> &GetInstance(std::shared_ptr<IFilesManager> *impl = nullptr);
+    virtual StatusCode Init(void);
+    virtual StatusCode UnInit(void);
+    virtual StatusCode SaveFile(const SaveFileInfo &fileInfo);
+};
+#endif

middleware/FilesManager/src/FilesDatabase.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FILES_DATABASE_H
+#define FILES_DATABASE_H
+#include "StatusCode.h"
+#include "FilesHandle.h"
+#include "IFilesManager.h"
+class FilesDatabase : public FilesHandle
+{
+public:
+    FilesDatabase() = default;
+    virtual ~FilesDatabase() = default;
+    void Init(void);
+    void UnInit(void);
+    StatusCode DatabaseSaveFile(const SaveFileInfo &fileInfo);
+};
+#endif

middleware/FilesManager/src/FilesHandle.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "FilesHandle.h"
+#include "ILog.h"
+#include <algorithm>
+#include <cctype>
+#include <chrono>
+#include <cstring>
+#include <ctime>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <sys/stat.h>
+#include <sys/types.h>
+std::string FilesHandle::CreateFilePathName(const std::string &sourceFile)
+{
+    const std::string ERROR_SUFFIX = "";
+    const char *dot = strrchr(sourceFile.c_str(), '.');
+    if (!dot || dot == sourceFile.c_str()) {
+        LogError("File suffix error.\n");
+        return ERROR_SUFFIX;
+    }
+    std::string fileSuffix = dot + 1;
+    if (fileSuffix != "jpg" && fileSuffix != "mp4" && fileSuffix != "JPG" && fileSuffix != "MP4") {
+        LogError("File suffix error.\n");
+        return ERROR_SUFFIX;
+    }
+    std::string fileType = (fileSuffix == "jpg" || fileSuffix == "JPG") ? "picture" : "video";
+    auto now = std::chrono::system_clock::now();
+    time_t t_now = std::chrono::system_clock::to_time_t(now);
+    struct tm tm_now = *std::localtime(&t_now);
+
+    int year = tm_now.tm_year + 1900;
+    int month = tm_now.tm_mon + 1;
+    int day = tm_now.tm_mday;
+    int hour = tm_now.tm_hour;
+    int minute = tm_now.tm_min;
+    int second = tm_now.tm_sec;
+
+    std::ostringstream pathStream;
+    pathStream << "/DCIM/" << fileType << "/" << std::setw(4) << std::setfill('0') << year << "/" << std::setw(2)
+               << std::setfill('0') << month << "/" << std::setw(2) << std::setfill('0') << day << "/" << std::setw(2)
+               << std::setfill('0') << hour << std::setw(2) << std::setfill('0') << minute << std::setw(2)
+               << std::setfill('0') << second << "." << fileSuffix;
+    return pathStream.str();
+}

middleware/FilesManager/src/FilesHandle.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FILES_HANDLE_H
+#define FILES_HANDLE_H
+#include <iostream>
+class FilesHandle
+{
+public:
+    FilesHandle() = default;
+    virtual ~FilesHandle() = default;
+    std::string CreateFilePathName(const std::string &sourceFile);
+};
+#endif

middleware/FilesManager/src/FilesManagerImpl.cpp

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "FilesManagerImpl.h"
+#include "IStorageManager.h"
+StatusCode FilesManagerImpl::Init(void)
+{
+    FilesDatabase::Init();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode FilesManagerImpl::UnInit(void)
+{
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StatusCode FilesManagerImpl::SaveFile(const SaveFileInfo &fileInfo)
+{
+    return FilesDatabase::DatabaseSaveFile(fileInfo);
+}

middleware/FilesManager/src/FilesManagerImpl.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FILES_MANAGER_IMPL_H
+#define FILES_MANAGER_IMPL_H
+#include "FilesDatabase.h"
+#include "IFilesManager.h"
+#include <map>
+class FilesManagerImpl : public IFilesManager, public FilesDatabase
+{
+public:
+    FilesManagerImpl() = default;
+    virtual ~FilesManagerImpl() = default;
+
+protected:
+    StatusCode Init(void) override;
+    StatusCode UnInit(void) override;
+    StatusCode SaveFile(const SaveFileInfo &fileInfo) override;
+};
+#endif