Add:SixFrame protocol.

CMakeLists.txt

@@ -60,6 +60,8 @@ if ("${CLANG_TIDY_SUPPORT}" MATCHES "true")
 		--header-filter=.*
 		--system-headers=false
 		${ALL_MODEFIED_FILES}
+		${CLANG_TIDY_CONFIG}
+		--line-filter='[{\"name\":\"${EXTERNAL_SOURCE_PATH}/gtest/googletest-release-1.11.0/googletest/include/getest/*.h\"}]'
 		-p ${PLATFORM_PATH}/cmake-shell
 		WORKING_DIRECTORY ${PLATFORM_PATH}
 	)

application/MissionManager/src/AppMonitor.cpp

@@ -60,7 +60,7 @@ StatusCode AppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
     param.mChargeStatus = ChargeStatus::CHARGING;
     return CreateStatusCode(STATUS_CODE_OK);
 }
-StatusCode AppMonitor::SetDateTime(AppSetDateTime &param)
+StatusCode AppMonitor::SetDateTime(const AppSetDateTime &param)
 {
     //
     return CreateStatusCode(STATUS_CODE_OK);

application/MissionManager/src/AppMonitor.h

@@ -25,7 +25,7 @@ public:
     StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
     StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
     StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
-    StatusCode SetDateTime(AppSetDateTime &param) override;
+    StatusCode SetDateTime(const AppSetDateTime &param) override;
     StatusCode SetTimeZone(const unsigned int &zone) override;
     StatusCode UploadFile(AppUploadFile &param) override;
 };

middleware/AppManager/include/IAppManager.h

@@ -62,6 +62,92 @@ enum class StorageType
     SD_CARD_2,
     END
 };
+enum class PlayBackEvent
+{
+    START = 0,
+    STOP,
+    END
+};
+enum class StorageFileType
+{
+    VIDEO = 0,
+    PICTURE,
+    END
+};
+enum class StorageFileEvent
+{
+    LOOP = 0,
+    PIR,
+    CRASH,
+    END
+};
+enum class MicStatus
+{
+    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
+};
 typedef struct app_get_product_info
 {
     app_get_product_info() {}
@@ -114,23 +200,34 @@ typedef struct app_get_battery_info
 } AppGetBatteryInfo;
 typedef struct app_get_param_value
 {
-    app_get_param_value()
+    app_get_param_value() { mMicStatus = MicStatus::END; }
-    {
+    MicStatus mMicStatus;
-        mCapacity = 0;
-        mChargeStatus = ChargeStatus::END;
-    }
-    int mCapacity;
-    ChargeStatus mChargeStatus;
 } AppGetParamValue;
 typedef struct app_get_capability
 {
     app_get_capability()
     {
-        mCapacity = 0;
+        mGpsCapability = GpsCapability::END;
-        mChargeStatus = ChargeStatus::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;
     }
-    int mCapacity;
+    GpsCapability mGpsCapability;
-    ChargeStatus mChargeStatus;
+    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
 {
@@ -147,6 +244,33 @@ typedef struct app_get_storage_info
     int mFree;
     int mTotal;
 } AppGetStorageInfo;
+typedef struct app_get_file_info
+{
+    app_get_file_info()
+    {
+        mStartIndex = 0;
+        mStopIndex = 0;
+        mEvent = StorageFileEvent::END;
+    }
+    int mStartIndex;
+    int mStopIndex;
+    StorageFileEvent mEvent;
+} AppGetFileInfo;
+typedef struct app_get_file_list
+{
+    app_get_file_list()
+    {
+        mDuration = 0;
+        mSize = 0;
+        mCreateTime_s = 0;
+        mType = StorageFileType::END;
+    }
+    std::string mName;
+    int mDuration;
+    int mSize;
+    time_t mCreateTime_s;
+    StorageFileType mType;
+} AppGetFileList;
 typedef struct app_set_param_value
 {
     app_set_param_value() { mValue = -1; }
@@ -191,10 +315,12 @@ public:
     virtual StatusCode GetCapability(AppGetCapability &param);
     virtual StatusCode GetLockVideoStatus(LockVideoStatus &param);
     virtual StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param);
-    virtual StatusCode SetDateTime(AppSetDateTime &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(AppSetParamValue &param);
+    virtual StatusCode SetParamValue(const AppSetParamValue &param);
     virtual StatusCode EnterRecorder(void);
+    virtual StatusCode AppPlayback(const PlayBackEvent &event);
     virtual StatusCode UploadFile(AppUploadFile &param);
 };
 typedef struct app_param

middleware/AppManager/src/IAppManager.cpp

@@ -47,13 +47,24 @@ StatusCode VAppMonitor::GetStorageInfo(std::vector<AppGetStorageInfo> &param)
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
-StatusCode VAppMonitor::SetDateTime(AppSetDateTime &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(AppSetParamValue &param)
+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); }
 std::shared_ptr<IAppManager> &IAppManager::GetInstance(std::shared_ptr<IAppManager> *impl)
 {

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

@@ -20,21 +20,25 @@ using std::placeholders::_1;
 using std::placeholders::_2;
 using std::placeholders::_3;
 // using std::placeholders::_4;
-const char *CJSON_INFO_STRING = "info";
+// clang-format off
-const char *APP_GET_PRODUCT_INFO = "/app/getproductinfo";
+const char *CJSON_INFO_STRING                 = "info";
-const char *APP_GET_DEVICE_ATTR = "/app/getdeviceattr";
+const char *APP_GET_PRODUCT_INFO              = "/app/getproductinfo";
-const char *APP_GET_MEDIA_INFO = "/app/getmediainfo";
+const char *APP_GET_DEVICE_ATTR               = "/app/getdeviceattr";
-const char *APP_GET_SD_CARD_INFO = "/app/getsdinfo";
+const char *APP_GET_MEDIA_INFO                = "/app/getmediainfo";
-const char *APP_GET_BATTERY_INFO = "/app/getbatteryinfo";
+const char *APP_GET_SD_CARD_INFO              = "/app/getsdinfo";
-const char *APP_GET_PARAM_VALUE = "/app/getparamvalue";
+const char *APP_GET_BATTERY_INFO              = "/app/getbatteryinfo";
-const char *APP_GET_CAPABILITY = "/app/capability";
+const char *APP_GET_PARAM_VALUE               = "/app/getparamvalue";
-const char *APP_GET_LOCK_VIDEO_STATUS = "/app/getlockvideostatus";
+const char *APP_GET_CAPABILITY                = "/app/capability";
-const char *APP_GET_STORAGE_INFO = "/app/getstorageinfo";
+const char *APP_GET_LOCK_VIDEO_STATUS         = "/app/getlockvideostatus";
-const char *APP_SET_DATE_TIME = "/app/setsystime";
+const char *APP_GET_STORAGE_INFO              = "/app/getstorageinfo";
-const char *APP_SET_TIME_ZONE = "/app/settimezone";
+const char *APP_GET_FILE_LIST                 = "/app/getfilelist";
-const char *APP_SET_PARAM_VALUE = "/app/setparamvalue";
+const char *APP_SET_DATE_TIME                 = "/app/setsystime";
-const char *APP_ENTER_RECORDER = "/app/enterrecorder";
+const char *APP_SET_TIME_ZONE                 = "/app/settimezone";
-const char *APP_UPLOAD_FILE = "/upload";
+const char *APP_SET_PARAM_VALUE               = "/app/setparamvalue";
+const char *APP_ENTER_RECORDER                = "/app/enterrecorder";
+const char *APP_PLAYBACK                      = "/app/playback";
+const char *APP_UPLOAD_FILE                   = "/upload";
+// clang-format on
 constexpr bool SET_REQUEST_RESPONSE = true;
 SixFrameHandle::SixFrameHandle()
 {
@@ -48,9 +52,13 @@ SixFrameHandle::SixFrameHandle()
     mResquesHandleFunc[APP_GET_CAPABILITY] = std::bind(&SixFrameHandle::RequestGetCapability, this, _1, _2, _3);
     mResquesHandleFunc[APP_GET_LOCK_VIDEO_STATUS] =
         std::bind(&SixFrameHandle::RequestGetLockVideoStatus, this, _1, _2, _3);
+    mResquesHandleFunc[APP_GET_STORAGE_INFO] = std::bind(&SixFrameHandle::RequestGetStorageInfo, this, _1, _2, _3);
+    mResquesHandleFunc[APP_GET_FILE_LIST] = std::bind(&SixFrameHandle::RequestGetFileList, this, _1, _2, _3);
     mResquesHandleFunc[APP_SET_DATE_TIME] = std::bind(&SixFrameHandle::RequestSetDateTime, this, _1, _2, _3);
     mResquesHandleFunc[APP_SET_TIME_ZONE] = std::bind(&SixFrameHandle::RequestSetTimeZone, this, _1, _2, _3);
+    mResquesHandleFunc[APP_SET_PARAM_VALUE] = std::bind(&SixFrameHandle::RequestSetParamValue, this, _1, _2, _3);
     mResquesHandleFunc[APP_ENTER_RECORDER] = std::bind(&SixFrameHandle::RequestEnterRecorder, this, _1, _2, _3);
+    mResquesHandleFunc[APP_PLAYBACK] = std::bind(&SixFrameHandle::RequestPlayback, this, _1, _2, _3);
     mResquesHandleFunc[APP_UPLOAD_FILE] = std::bind(&SixFrameHandle::RequestUpload, this, _1, _2, _3);
     // mResquesHandleFunc["favicon.ico"] = std::bind(&SixFrameHandle::DoNothing, this, _1, _2, _);
 }
@@ -190,6 +198,7 @@ void inline SixFrameHandle::ResponseGetMediaInfo(cJSON *result, const AppGetMeid
     cJSON_AddStringToObject(info, "rtsp", param.mRtspUrl.c_str());
     cJSON_AddStringToObject(info, "transport", param.mTransport.c_str());
     cJSON_AddNumberToObject(info, "port", param.mPort);
+    cJSON_AddNumberToObject(info, "page", 1); // TODO: 1 means app will paging to retrieve files.
 }
 void SixFrameHandle::RequestGetSdCardInfo(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -253,10 +262,18 @@ void SixFrameHandle::RequestGetParamValue(const std::string &url, ResponseHandle
 }
 void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppGetParamValue &param)
 {
-    cJSON *info = nullptr;
+    cJSON *info = cJSON_CreateArray();
-    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    if (nullptr == info) {
-    cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
+        LogError("cJSON_CreateArray failed.\n");
-    cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
+        return;
+    }
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info);
+    cJSON *mic = cJSON_CreateObject();
+    if (nullptr != mic) {
+        cJSON_AddItemToArray(info, mic);
+        cJSON_AddStringToObject(mic, "name", "mic");
+        cJSON_AddNumberToObject(mic, "value", static_cast<int>(param.mMicStatus));
+    }
 }
 void SixFrameHandle::RequestGetCapability(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -277,8 +294,18 @@ void inline SixFrameHandle::ResponseGetCapability(cJSON *result, const AppGetCap
 {
     cJSON *info = nullptr;
     cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
-    cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
+    std::ostringstream value;
-    cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
+    value << static_cast<int>(param.mGpsCapability);
+    value << static_cast<int>(param.mDeviceType);
+    value << static_cast<int>(param.mAlbum);
+    value << static_cast<int>(param.mAppLock);
+    value << static_cast<int>(param.mDeleteLock);
+    value << static_cast<int>(param.mDeviceMode);
+    value << static_cast<int>(param.mPlaybackType);
+    value << static_cast<int>(param.mPhotographCapability);
+    value << static_cast<int>(param.mWifiCapability);
+    value << static_cast<int>(param.mFileCopy);
+    cJSON_AddStringToObject(info, "value", value.str().c_str());
 }
 void SixFrameHandle::RequestGetLockVideoStatus(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -337,6 +364,74 @@ void inline SixFrameHandle::ResponseGetStorageInfo(cJSON *result, const std::vec
         }
     }
 }
+AppGetFileInfo inline SixFrameHandle::RequestGetFileListParse(const std::string &url)
+{
+    auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
+        std::shared_ptr<ParseUrl<AppGetFileInfo>> parseyImpl =
+            std::dynamic_pointer_cast<ParseUrl<AppGetFileInfo>>(parse);
+        if ("folder" == key) {
+            if ("loop" == value) {
+                parseyImpl->mData.mEvent = StorageFileEvent::END;
+            }
+            if ("emr" == value) {
+                parseyImpl->mData.mEvent = StorageFileEvent::END;
+            }
+            if ("event" == value) {
+                parseyImpl->mData.mEvent = StorageFileEvent::END;
+            }
+            if ("park" == value) {
+                parseyImpl->mData.mEvent = StorageFileEvent::END;
+            }
+        }
+        if ("start" == key) {
+            parseyImpl->mData.mStartIndex = std::stoi(value);
+        }
+        if ("end" == key) {
+            parseyImpl->mData.mStopIndex = std::stoi(value);
+        }
+    };
+    std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<AppGetFileInfo>>();
+    std::shared_ptr<ParseUrl<AppGetFileInfo>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<AppGetFileInfo>>(parse);
+    ExtractParamsFromUrl(url, parseFunc, parse);
+    return parseyImpl->mData;
+}
+void SixFrameHandle::RequestGetFileList(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetFileList.\n");
+    std::vector<AppGetFileList> param;
+    AppGetFileInfo info = RequestGetFileListParse(url);
+    mAppMonitor->GetStorageFileList(info, param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    ResponseGetFileList(result, param);
+    ResponseJsonString(result, responseHandle, context);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetFileList(cJSON *result, const std::vector<AppGetFileList> &param)
+{
+    cJSON *info = cJSON_CreateArray();
+    if (nullptr == info) {
+        LogError("cJSON_CreateArray failed.\n");
+        return;
+    }
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info);
+    for (const auto &fileInfo : param) {
+        cJSON *file = nullptr;
+        file = cJSON_CreateObject();
+        if (nullptr != file) {
+            cJSON_AddItemToArray(info, file);
+            cJSON_AddStringToObject(file, "name", fileInfo.mName.c_str());
+            cJSON_AddNumberToObject(file, "duration", fileInfo.mDuration);
+            cJSON_AddNumberToObject(file, "size", fileInfo.mSize);
+            cJSON_AddNumberToObject(file, "createtime", fileInfo.mCreateTime_s);
+            cJSON_AddNumberToObject(file, "type", static_cast<int>(fileInfo.mType));
+        }
+    }
+}
 AppSetDateTime inline SixFrameHandle::RequestSetDateTimeParse(const std::string &url)
 {
     auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
@@ -451,6 +546,39 @@ void SixFrameHandle::RequestSetParamValue(const std::string &url, ResponseHandle
     ResponseJsonString(result, responseHandle, context);
     cJSON_Delete(result);
 }
+PlayBackEvent inline SixFrameHandle::RequestPlaybackParse(const std::string &url)
+{
+    auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
+        std::shared_ptr<ParseUrl<PlayBackEvent>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
+        if ("param" == key) {
+            if ("enter" == value) {
+                parseyImpl->mData = PlayBackEvent::START;
+            }
+            if ("exit" == value) {
+                parseyImpl->mData = PlayBackEvent::STOP;
+            }
+        }
+    };
+    std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<PlayBackEvent>>();
+    std::shared_ptr<ParseUrl<PlayBackEvent>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
+    parseyImpl->mData = PlayBackEvent::END;
+    ExtractParamsFromUrl(url, parseFunc, parse);
+    return parseyImpl->mData;
+}
+void SixFrameHandle::RequestPlayback(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestPlayback.\n");
+    PlayBackEvent value = RequestPlaybackParse(url);
+    mAppMonitor->AppPlayback(value);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL, SET_REQUEST_RESPONSE);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    ResponseJsonString(result, responseHandle, context);
+    cJSON_Delete(result);
+}
 void SixFrameHandle::RequestEnterRecorder(const std::string &url, ResponseHandle responseHandle, void *context)
 {
     LogInfo("RequestEnterRecorder.\n");

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

@@ -76,12 +76,17 @@ private:
     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);
     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);
 

test/application/MissionManager/tool/src/TestMissionStateMock.cpp

@@ -60,7 +60,7 @@ StatusCode TestMissionStateTest::GetBatteryInfo(AppGetBatteryInfo &param)
     }
     return code;
 }
-StatusCode TestMissionStateTest::SetDateTime(AppSetDateTime &param)
+StatusCode TestMissionStateTest::SetDateTime(const AppSetDateTime &param)
 {
     LogInfo("TestMissionStateTest::SetDateTime\n");
     LogInfo("mYear = %u\n", param.mYear);

test/application/MissionManager/tool/src/TestMissionStateMock.h

@@ -27,7 +27,7 @@ public:
     StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
     StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
     StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
-    StatusCode SetDateTime(AppSetDateTime &param) override;
+    StatusCode SetDateTime(const AppSetDateTime &param) override;
     StatusCode SetTimeZone(const unsigned int &zone) override;
     StatusCode UploadFile(AppUploadFile &param) override;
     // const StatusCode SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor) override;

test/middleware/AppManager/CMakeLists.txt

@@ -34,7 +34,7 @@ endif()
 
 set(TARGET_NAME AppManagerTest)
 add_executable(${TARGET_NAME} ${SRC_FILES_MAIN} ${SRC_FILES})
-target_link_libraries(${TARGET_NAME} AppManagerTestTool gtest gmock pthread)
+target_link_libraries(${TARGET_NAME} AppManagerTestTool HalTestTool gtest gmock pthread)
 if(${TEST_COVERAGE} MATCHES "true")
     target_link_libraries(${TARGET_NAME} gcov)
 endif()

test/middleware/AppManager/src/AppManager_Test.cpp

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include "AppManagerTestTool.h"
+#include "HalTestTool.h"
 #include "IAppManager.h"
 #include "ILog.h"
 #include <gmock/gmock.h>
@@ -20,7 +21,7 @@
 #include <thread>
 namespace AppManagerTest
 {
-class AppManagerTest : public testing::Test, public AppManagerTestTool
+class AppManagerTest : public testing::Test, public AppManagerTestTool, public HalTestTool
 {
 public:
     AppManagerTest() : mAppParam(APP_MANAGER_HTTP_SERVER_IP, APP_MANAGER_HTTP_SERVER_PORT) {}
@@ -33,13 +34,17 @@ public:
     static void TearDownTestCase() { ILogUnInit(); }
     virtual void SetUp()
     {
+        HalTestTool::Init();
         AppManagerTestTool::Init();
+        CreateHalCppModule();
         CreateAppManagerModule();
     }
     virtual void TearDown()
     {
         AppManagerTestTool::UnInit();
+        HalTestTool::UnInit();
         DestroyAppManagerModule();
+        DestroyHalCppModule();
     }
 
 protected:
@@ -145,4 +150,100 @@ TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_SetTimeZone)
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     IAppManager::GetInstance()->UnInit();
 }
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetParamValue
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetParamValue)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetParamValue();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetCapability
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetCapability)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetCapability();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetLockVideoStatus
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetLockVideoStatus)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetLockVideoStatus();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageInfo
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageInfo)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetStorageInfo();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageFileList
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetStorageFileList)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetStorageFileList();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_SetParamValue
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_SetParamValue)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockSetParamValue();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_EnterRecorder
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_EnterRecorder)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockEnterRecorder();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_AppPlayback
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_AppPlayback)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockAppPlayback();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
 } // namespace AppManagerTest

test/middleware/AppManager/tool/include/AppManagerTestTool.h

@@ -34,6 +34,14 @@ protected:
     void MockSetDateTime(void);
     void MockSetTimeZone(void);
     void MockUploadFiles(void);
+    void MockGetParamValue(void);
+    void MockGetCapability(void);
+    void MockGetLockVideoStatus(void);
+    void MockGetStorageInfo(void);
+    void MockGetStorageFileList(void);
+    void MockSetParamValue(void);
+    void MockEnterRecorder(void);
+    void MockAppPlayback(void);
 
 private:
     void AppManagerMockInit(std::shared_ptr<IAppManager> &vMock);

test/middleware/AppManager/tool/src/AppManagerTestTool.cpp

@@ -114,6 +114,86 @@ void AppManagerTestTool::MockUploadFiles(void)
     }
     ServersMock::GetInstance()->MockUploadFiles();
 }
+void AppManagerTestTool::MockGetParamValue(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), GetParamValueTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockGetParamValue();
+}
+void AppManagerTestTool::MockGetCapability(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), GetCapabilityTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockGetCapability();
+}
+void AppManagerTestTool::MockGetLockVideoStatus(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), GetLockVideoStatusTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockGetLockVideoStatus();
+}
+void AppManagerTestTool::MockGetStorageInfo(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), GetStorageInfoTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockGetStorageInfo();
+}
+void AppManagerTestTool::MockGetStorageFileList(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), GetStorageFileListTrace(_, _))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockGetStorageFileList();
+}
+void AppManagerTestTool::MockSetParamValue(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), SetParamValueTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockSetParamValue();
+}
+void AppManagerTestTool::MockEnterRecorder(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), EnterRecorderTrace())
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockEnterRecorder();
+}
+void AppManagerTestTool::MockAppPlayback(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (mock) {
+        EXPECT_CALL(*mock.get(), AppPlaybackTrace(_))
+            .Times(ONLY_BE_CALLED_ONCE)
+            .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    }
+    ServersMock::GetInstance()->MockAppPlayback();
+}
 void AppManagerTestTool::AppManagerMockInit(std::shared_ptr<IAppManager> &vMock)
 {
     std::shared_ptr<AppManagerMock> mock = std::dynamic_pointer_cast<AppManagerMock>(vMock);
@@ -155,10 +235,28 @@ void AppManagerTestTool::AppMonitorInit(std::shared_ptr<VAppMonitor> &vMock)
             .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
         EXPECT_CALL(*mock.get(), GetSdCardInfoTrace(_))
             .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), GetParamValueTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), GetCapabilityTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), GetLockVideoStatusTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), GetStorageInfoTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), GetStorageFileListTrace(_, _))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
         EXPECT_CALL(*mock.get(), GetBatteryInfoTrace(_))
             .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
         EXPECT_CALL(*mock.get(), SetDateTimeTrace(_))
             .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), SetTimeZoneTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), SetParamValueTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), EnterRecorderTrace())
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+        EXPECT_CALL(*mock.get(), AppPlaybackTrace(_))
+            .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
         EXPECT_CALL(*mock.get(), UploadFileTrace(_))
             .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     }

test/middleware/AppManager/tool/src/AppMonitorMock.cpp

@@ -84,7 +84,77 @@ StatusCode AppMonitorTrace::GetBatteryInfoTrace(AppGetBatteryInfo &param)
     LogInfo("AppMonitorTrace::GetBatteryInfoTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
-StatusCode AppMonitorTest::SetDateTime(AppSetDateTime &param)
+StatusCode AppMonitorTest::GetParamValue(AppGetParamValue &param)
+{
+    LogInfo("AppMonitorTest::GetParamValue\n");
+    StatusCode code = GetParamValueTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetParamValue(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::GetParamValueTrace(AppGetParamValue &param)
+{
+    LogInfo("AppMonitorTrace::GetParamValueTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetCapability(AppGetCapability &param)
+{
+    LogInfo("AppMonitorTest::GetCapability\n");
+    StatusCode code = GetCapabilityTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetCapability(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::GetCapabilityTrace(AppGetCapability &param)
+{
+    LogInfo("AppMonitorTrace::GetCapabilityTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetLockVideoStatus(LockVideoStatus &param)
+{
+    LogInfo("AppMonitorTest::GetLockVideoStatus\n");
+    StatusCode code = GetLockVideoStatusTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetLockVideoStatus(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::GetLockVideoStatusTrace(LockVideoStatus &param)
+{
+    LogInfo("AppMonitorTrace::GetLockVideoStatusTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetStorageInfo(std::vector<AppGetStorageInfo> &param)
+{
+    LogInfo("AppMonitorTest::GetStorageInfo\n");
+    StatusCode code = GetStorageInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetStorageInfo(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::GetStorageInfoTrace(std::vector<AppGetStorageInfo> &param)
+{
+    LogInfo("AppMonitorTrace::GetStorageInfoTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetStorageFileList(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
+{
+    LogInfo("AppMonitorTest::GetStorageFileList\n");
+    StatusCode code = GetStorageFileListTrace(fileInfo, param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetStorageFileList(fileInfo, param);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::GetStorageFileListTrace(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param)
+{
+    LogInfo("AppMonitorTrace::GetStorageFileListTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::SetDateTime(const AppSetDateTime &param)
 {
     LogInfo("AppMonitorTest::SetDateTime\n");
     LogInfo("mYear = %u\n", param.mYear);
@@ -99,7 +169,7 @@ StatusCode AppMonitorTest::SetDateTime(AppSetDateTime &param)
     }
     return code;
 }
-StatusCode AppMonitorTrace::SetDateTimeTrace(AppSetDateTime &param)
+StatusCode AppMonitorTrace::SetDateTimeTrace(const AppSetDateTime &param)
 {
     LogInfo("AppMonitorTrace::SetDateTimeTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
@@ -118,6 +188,48 @@ StatusCode AppMonitorTrace::SetTimeZoneTrace(const unsigned int &zone)
     LogInfo("AppMonitorTrace::SetTimeZoneTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode AppMonitorTest::SetParamValue(const AppSetParamValue &param)
+{
+    LogInfo("AppMonitorTest::SetParamValue\n");
+    StatusCode code = SetParamValueTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::SetParamValue(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::SetParamValueTrace(const AppSetParamValue &param)
+{
+    LogInfo("AppMonitorTrace::SetParamValueTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::EnterRecorder(void)
+{
+    LogInfo("AppMonitorTest::EnterRecorder\n");
+    StatusCode code = EnterRecorderTrace();
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::EnterRecorder();
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::EnterRecorderTrace(void)
+{
+    LogInfo("AppMonitorTrace::EnterRecorderTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::AppPlayback(const PlayBackEvent &event)
+{
+    LogInfo("AppMonitorTest::AppPlayback\n");
+    StatusCode code = AppPlaybackTrace(event);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::AppPlayback(event);
+    }
+    return code;
+}
+StatusCode AppMonitorTrace::AppPlaybackTrace(const PlayBackEvent &event)
+{
+    LogInfo("AppMonitorTrace::AppPlaybackTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
 StatusCode AppMonitorTest::UploadFile(AppUploadFile &param)
 {
     LogInfo("AppMonitorTest::UploadFile\n");

test/middleware/AppManager/tool/src/AppMonitorMock.h

@@ -28,8 +28,16 @@ protected:
     virtual StatusCode GetMediaInfoTrace(AppGetMeidaInfo &param);
     virtual StatusCode GetSdCardInfoTrace(AppGetSdCardInfo &param);
     virtual StatusCode GetBatteryInfoTrace(AppGetBatteryInfo &param);
-    virtual StatusCode SetDateTimeTrace(AppSetDateTime &param);
+    virtual StatusCode GetParamValueTrace(AppGetParamValue &param);
+    virtual StatusCode GetCapabilityTrace(AppGetCapability &param);
+    virtual StatusCode GetLockVideoStatusTrace(LockVideoStatus &param);
+    virtual StatusCode GetStorageInfoTrace(std::vector<AppGetStorageInfo> &param);
+    virtual StatusCode GetStorageFileListTrace(const AppGetFileInfo &fileInfo, std::vector<AppGetFileList> &param);
+    virtual StatusCode SetDateTimeTrace(const AppSetDateTime &param);
     virtual StatusCode SetTimeZoneTrace(const unsigned int &zone);
+    virtual StatusCode SetParamValueTrace(const AppSetParamValue &param);
+    virtual StatusCode EnterRecorderTrace(void);
+    virtual StatusCode AppPlaybackTrace(const PlayBackEvent &event);
     virtual StatusCode UploadFileTrace(AppUploadFile &param);
 };
 class AppMonitorTest : public VAppMonitor, virtual public AppMonitorTrace
@@ -42,8 +50,16 @@ public:
     StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
     StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
     StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
-    StatusCode SetDateTime(AppSetDateTime &param) override;
+    StatusCode GetParamValue(AppGetParamValue &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;
 };
 class AppMonitorMock : virtual public AppMonitorTrace
@@ -56,8 +72,16 @@ public:
     MOCK_METHOD1(GetMediaInfoTrace, StatusCode(AppGetMeidaInfo &));
     MOCK_METHOD1(GetSdCardInfoTrace, StatusCode(AppGetSdCardInfo &));
     MOCK_METHOD1(GetBatteryInfoTrace, StatusCode(AppGetBatteryInfo &));
-    MOCK_METHOD1(SetDateTimeTrace, StatusCode(AppSetDateTime &));
+    MOCK_METHOD1(GetParamValueTrace, StatusCode(AppGetParamValue &));
+    MOCK_METHOD1(GetCapabilityTrace, StatusCode(AppGetCapability &));
+    MOCK_METHOD1(GetLockVideoStatusTrace, StatusCode(LockVideoStatus &));
+    MOCK_METHOD1(GetStorageInfoTrace, StatusCode(std::vector<AppGetStorageInfo> &));
+    MOCK_METHOD2(GetStorageFileListTrace, StatusCode(const AppGetFileInfo &, std::vector<AppGetFileList> &));
+    MOCK_METHOD1(SetDateTimeTrace, StatusCode(const AppSetDateTime &));
     MOCK_METHOD1(SetTimeZoneTrace, StatusCode(const unsigned int &));
+    MOCK_METHOD1(SetParamValueTrace, StatusCode(const AppSetParamValue &));
+    MOCK_METHOD0(EnterRecorderTrace, StatusCode(void));
+    MOCK_METHOD1(AppPlaybackTrace, StatusCode(const PlayBackEvent &));
     MOCK_METHOD1(UploadFileTrace, StatusCode(AppUploadFile &));
 };
 #endif

test/middleware/AppManager/tool/src/ServersMock.cpp

@@ -21,8 +21,16 @@ extern const char *APP_GET_DEVICE_ATTR;
 extern const char *APP_GET_MEDIA_INFO;
 extern const char *APP_GET_SD_CARD_INFO;
 extern const char *APP_GET_BATTERY_INFO;
+extern const char *APP_GET_PARAM_VALUE;
+extern const char *APP_GET_CAPABILITY;
+extern const char *APP_GET_LOCK_VIDEO_STATUS;
+extern const char *APP_GET_STORAGE_INFO;
+extern const char *APP_GET_FILE_LIST;
 extern const char *APP_SET_DATE_TIME;
 extern const char *APP_SET_TIME_ZONE;
+extern const char *APP_SET_PARAM_VALUE;
+extern const char *APP_ENTER_RECORDER;
+extern const char *APP_PLAYBACK;
 extern const char *APP_UPLOAD_FILE;
 std::shared_ptr<ServersMock> &ServersMock::GetInstance(std::shared_ptr<ServersMock> *impl)
 {
@@ -140,9 +148,94 @@ void ServersMock::MockGetBatteryInfo(void)
         DeleteServersHttp(http);
     }
 }
+void ServersMock::MockGetParamValue(void)
+{
+    LogInfo("APP_GET_PARAM_VALUE test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_PARAM_VALUE;
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
+void ServersMock::MockGetCapability(void)
+{
+    LogInfo("APP_GET_CAPABILITY test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_CAPABILITY;
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
+void ServersMock::MockGetLockVideoStatus(void)
+{
+    LogInfo("APP_GET_LOCK_VIDEO_STATUS test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_LOCK_VIDEO_STATUS;
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
+void ServersMock::MockGetStorageInfo(void)
+{
+    LogInfo("APP_GET_STORAGE_INFO test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_STORAGE_INFO;
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
+void ServersMock::MockGetStorageFileList(void)
+{
+    LogInfo("APP_GET_FILE_LIST test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_FILE_LIST;
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
 void ServersMock::MockSetDateTime(void)
 {
-    LogInfo("APP_GET_BATTERY_INFO test start.\n");
+    LogInfo("APP_SET_DATE_TIME test start.\n");
     std::string mockRequest = mServerUrl + APP_SET_DATE_TIME + "?date=20240101010101";
     ServerHttp *http = NewServersHttp(mockRequest.c_str());
     if (http) {
@@ -174,6 +267,57 @@ void ServersMock::MockSetTimeZone(void)
         DeleteServersHttp(http);
     }
 }
+void ServersMock::MockSetParamValue(void)
+{
+    LogInfo("APP_SET_PARAM_VALUE test start.\n");
+    std::string mockRequest = mServerUrl + APP_SET_PARAM_VALUE + "?timezone=8";
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
+void ServersMock::MockEnterRecorder(void)
+{
+    LogInfo("APP_ENTER_RECORDER test start.\n");
+    std::string mockRequest = mServerUrl + APP_ENTER_RECORDER + "?timezone=8";
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
+void ServersMock::MockAppPlayback(void)
+{
+    LogInfo("APP_PLAYBACK test start.\n");
+    std::string mockRequest = mServerUrl + APP_PLAYBACK + "?timezone=8";
+    ServerHttp *http = NewServersHttp(mockRequest.c_str());
+    if (http) {
+        HttpGet(http);
+        if (http->reply) {
+            char *replyStr = (char *)malloc(http->replyLength + 1);
+            memset(replyStr, 0, http->replyLength + 1);
+            memcpy(replyStr, http->reply, http->replyLength);
+            LogInfo("HttpGet response :\n%s\n", replyStr);
+            free(replyStr);
+        }
+        DeleteServersHttp(http);
+    }
+}
 #ifndef PLATFORM_PATH
     #error Add the code in your linux.toolchain.cmake : add_definitions(-DPLATFORM_PATH="${PLATFORM_PATH}")
 #endif

test/middleware/AppManager/tool/src/ServersMock.h

@@ -28,8 +28,16 @@ public:
     virtual void MockGetMediaInfo(void);
     virtual void MockGetSdCardInfo(void);
     virtual void MockGetBatteryInfo(void);
+    virtual void MockGetParamValue(void);
+    virtual void MockGetCapability(void);
+    virtual void MockGetLockVideoStatus(void);
+    virtual void MockGetStorageInfo(void);
+    virtual void MockGetStorageFileList(void);
     virtual void MockSetDateTime(void);
     virtual void MockSetTimeZone(void);
+    virtual void MockSetParamValue(void);
+    virtual void MockEnterRecorder(void);
+    virtual void MockAppPlayback(void);
     virtual void MockUploadFiles(void);
 
 private: