Improve:SixFrame protocol.

application/MissionManager/src/AppMonitor.cpp

@@ -60,9 +60,10 @@ StatusCode AppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
     param.mChargeStatus = ChargeStatus::CHARGING;
     return CreateStatusCode(STATUS_CODE_OK);
 }
-StatusCode AppMonitor::GetParamValue(AppGetParamValue &param)
+StatusCode AppMonitor::GetParamValue(AppParamValue &param)
 {
-    param.mMicStatus = MicStatus::ON;
+    param.mMicStatus = SwitchStatus::ON;
+    param.mRec = SwitchStatus::OFF;
     return CreateStatusCode(STATUS_CODE_OK);
 }
 StatusCode AppMonitor::GetCapability(AppGetCapability &param)

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 GetParamValue(AppGetParamValue &param) override;
+    StatusCode GetParamValue(AppParamValue &param) override;
     StatusCode GetCapability(AppGetCapability &param) override;
     StatusCode GetLockVideoStatus(LockVideoStatus &param) override;
     StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param) override;

middleware/AppManager/include/IAppManager.h

@@ -84,7 +84,7 @@ enum class StorageFileEvent
     PARK,
     END
 };
-enum class MicStatus
+enum class SwitchStatus
 {
     OFF = 0,
     ON,
@@ -203,9 +203,14 @@ typedef struct app_get_battery_info
 } AppGetBatteryInfo;
 typedef struct app_get_param_value
 {
-    app_get_param_value() { mMicStatus = MicStatus::END; }
+    app_get_param_value()
-    MicStatus mMicStatus;
+    {
-} AppGetParamValue;
+        mRec = SwitchStatus::END;
+        mMicStatus = SwitchStatus::END;
+    }
+    SwitchStatus mMicStatus;
+    SwitchStatus mRec;
+} AppParamValue;
 typedef struct app_get_capability
 {
     app_get_capability()
@@ -320,7 +325,7 @@ public:
     virtual StatusCode GetMediaInfo(AppGetMeidaInfo &param);
     virtual StatusCode GetSdCardInfo(AppGetSdCardInfo &param);
     virtual StatusCode GetBatteryInfo(AppGetBatteryInfo &param);
-    virtual StatusCode GetParamValue(AppGetParamValue &param);
+    virtual StatusCode GetParamValue(AppParamValue &param);
     virtual StatusCode GetCapability(AppGetCapability &param);
     virtual StatusCode GetLockVideoStatus(LockVideoStatus &param);
     virtual StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param);

middleware/AppManager/src/IAppManager.cpp

@@ -31,10 +31,7 @@ StatusCode VAppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
-StatusCode VAppMonitor::GetParamValue(AppGetParamValue &param)
+StatusCode VAppMonitor::GetParamValue(AppParamValue &param) { return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION); }
-{
-    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
-}
 StatusCode VAppMonitor::GetCapability(AppGetCapability &param)
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);

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

@@ -250,22 +250,38 @@ void inline SixFrameHandle::ResponseGetBatteryInfo(cJSON *result, const AppGetBa
     cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
     cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
 }
+AppParamValue inline SixFrameHandle::RequestParamValueParse(const std::string &url)
+{
+    auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
+        std::shared_ptr<ParseUrl<AppParamValue>> parseImpl = std::dynamic_pointer_cast<ParseUrl<AppParamValue>>(parse);
+        if ("param" == key) {
+            if ("rec" == value) {
+                parseImpl->mData.mRec = SwitchStatus::ON; // means app want to get mRec value.
+            }
+        }
+    };
+    std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<AppParamValue>>();
+    std::shared_ptr<ParseUrl<AppParamValue>> parseImpl = std::dynamic_pointer_cast<ParseUrl<AppParamValue>>(parse);
+    ExtractParamsFromUrl(url, parseFunc, parse);
+    return parseImpl->mData;
+}
 void SixFrameHandle::RequestGetParamValue(const std::string &url, ResponseHandle responseHandle, void *context)
 {
     LogInfo("RequestGetParamValue.\n");
-    AppGetParamValue param;
+    // AppParamValue appGetValue = RequestParamValueParse(url); // TODO:
-    mAppMonitor->GetParamValue(param);
+    AppParamValue paramDevice;
+    mAppMonitor->GetParamValue(paramDevice);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
     if (nullptr == result) {
         LogError("MakeResponseResult failed.\n");
         responseHandle("Device run out of memory.", context);
         return;
     }
-    ResponseGetParamValue(result, param);
+    ResponseGetParamValue(result, paramDevice);
     ResponseJsonString(result, responseHandle, context);
     cJSON_Delete(result);
 }
-void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppGetParamValue &param)
+void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppParamValue &param)
 {
     cJSON *info = cJSON_CreateArray();
     if (nullptr == info) {
@@ -279,6 +295,12 @@ void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppGetPar
         cJSON_AddStringToObject(mic, "name", "mic");
         cJSON_AddNumberToObject(mic, "value", static_cast<int>(param.mMicStatus));
     }
+    cJSON *rec = cJSON_CreateObject();
+    if (nullptr != rec) {
+        cJSON_AddItemToArray(info, rec);
+        cJSON_AddStringToObject(rec, "name", "rec");
+        cJSON_AddNumberToObject(rec, "value", static_cast<int>(param.mRec));
+    }
 }
 void SixFrameHandle::RequestGetCapability(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -372,33 +394,33 @@ 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::shared_ptr<ParseUrl<AppGetFileInfo>> parseImpl =
             std::dynamic_pointer_cast<ParseUrl<AppGetFileInfo>>(parse);
         if ("folder" == key) {
             if ("loop" == value) {
-                parseyImpl->mData.mEvent = StorageFileEvent::LOOP;
+                parseImpl->mData.mEvent = StorageFileEvent::LOOP;
             }
             if ("emr" == value) {
-                parseyImpl->mData.mEvent = StorageFileEvent::EMR;
+                parseImpl->mData.mEvent = StorageFileEvent::EMR;
             }
             if ("event" == value) {
-                parseyImpl->mData.mEvent = StorageFileEvent::EVENT;
+                parseImpl->mData.mEvent = StorageFileEvent::EVENT;
             }
             if ("park" == value) {
-                parseyImpl->mData.mEvent = StorageFileEvent::PARK;
+                parseImpl->mData.mEvent = StorageFileEvent::PARK;
             }
         }
         if ("start" == key) {
-            parseyImpl->mData.mStartIndex = std::stoi(value);
+            parseImpl->mData.mStartIndex = std::stoi(value);
         }
         if ("end" == key) {
-            parseyImpl->mData.mStopIndex = std::stoi(value);
+            parseImpl->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);
+    std::shared_ptr<ParseUrl<AppGetFileInfo>> parseImpl = std::dynamic_pointer_cast<ParseUrl<AppGetFileInfo>>(parse);
     ExtractParamsFromUrl(url, parseFunc, parse);
-    return parseyImpl->mData;
+    return parseImpl->mData;
 }
 void SixFrameHandle::RequestGetFileList(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -467,24 +489,24 @@ void inline SixFrameHandle::ResponseGetFileList(cJSON *result, const std::vector
 AppSetDateTime inline SixFrameHandle::RequestSetDateTimeParse(const std::string &url)
 {
     auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
-        std::shared_ptr<ParseUrl<std::string>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
+        std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
         if ("date" == key) {
-            parseyImpl->mData = value;
+            parseImpl->mData = value;
         }
     };
     std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<std::string>>();
     ExtractParamsFromUrl(url, parseFunc, parse);
-    std::shared_ptr<ParseUrl<std::string>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
+    std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
-    if (14 != parseyImpl->mData.length()) {
+    if (14 != parseImpl->mData.length()) {
         LogError("date parse failed.\n");
         return AppSetDateTime(0, 0, 0, 0, 0, 0);
     }
-    std::string yearStr = parseyImpl->mData.substr(0, 4);
+    std::string yearStr = parseImpl->mData.substr(0, 4);
-    std::string monthStr = parseyImpl->mData.substr(4, 2);
+    std::string monthStr = parseImpl->mData.substr(4, 2);
-    std::string dayStr = parseyImpl->mData.substr(6, 2);
+    std::string dayStr = parseImpl->mData.substr(6, 2);
-    std::string hourStr = parseyImpl->mData.substr(8, 2);
+    std::string hourStr = parseImpl->mData.substr(8, 2);
-    std::string minuteStr = parseyImpl->mData.substr(10, 2);
+    std::string minuteStr = parseImpl->mData.substr(10, 2);
-    std::string secondStr = parseyImpl->mData.substr(12, 2);
+    std::string secondStr = parseImpl->mData.substr(12, 2);
     unsigned int year = std::stoi(yearStr);
     unsigned int month = std::stoi(monthStr);
     unsigned int day = std::stoi(dayStr);
@@ -510,19 +532,19 @@ void SixFrameHandle::RequestSetDateTime(const std::string &url, ResponseHandle r
 int inline SixFrameHandle::RequestSetTimeZoneParse(const std::string &url)
 {
     auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
-        std::shared_ptr<ParseUrl<std::string>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
+        std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
         if ("timezone" == key) {
-            parseyImpl->mData = value;
+            parseImpl->mData = value;
         }
     };
     std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<std::string>>();
     ExtractParamsFromUrl(url, parseFunc, parse);
-    std::shared_ptr<ParseUrl<std::string>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
+    std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
-    if (2 <= parseyImpl->mData.length()) {
+    if (2 <= parseImpl->mData.length()) {
         LogError("date parse failed.\n");
         return 0;
     }
-    int zone = std::stoi(parseyImpl->mData);
+    int zone = std::stoi(parseImpl->mData);
     return zone;
 }
 void SixFrameHandle::RequestSetTimeZone(const std::string &url, ResponseHandle responseHandle, void *context)
@@ -542,27 +564,27 @@ void SixFrameHandle::RequestSetTimeZone(const std::string &url, ResponseHandle r
 AppSetParamValue inline SixFrameHandle::RequestSetParamValueParse(const std::string &url)
 {
     auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
-        std::shared_ptr<ParseUrl<AppSetParamValue>> parseyImpl =
+        std::shared_ptr<ParseUrl<AppSetParamValue>> parseImpl =
             std::dynamic_pointer_cast<ParseUrl<AppSetParamValue>>(parse);
         if ("switchcam" == key) {
-            parseyImpl->mData.mName = "switchcam";
+            parseImpl->mData.mName = "switchcam";
-            parseyImpl->mData.mValue = std::stoi(value);
+            parseImpl->mData.mValue = std::stoi(value);
         }
         if ("rec" == key) {
-            parseyImpl->mData.mName = "rec";
+            parseImpl->mData.mName = "rec";
-            parseyImpl->mData.mValue = std::stoi(value);
+            parseImpl->mData.mValue = std::stoi(value);
         }
         if ("mic" == key) {
-            parseyImpl->mData.mName = "mic";
+            parseImpl->mData.mName = "mic";
-            parseyImpl->mData.mValue = std::stoi(value);
+            parseImpl->mData.mValue = std::stoi(value);
         }
     };
     AppSetParamValue value;
     std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<AppSetParamValue>>();
     ExtractParamsFromUrl(url, parseFunc, parse);
-    std::shared_ptr<ParseUrl<AppSetParamValue>> parseyImpl =
+    std::shared_ptr<ParseUrl<AppSetParamValue>> parseImpl =
         std::dynamic_pointer_cast<ParseUrl<AppSetParamValue>>(parse);
-    return parseyImpl->mData;
+    return parseImpl->mData;
 }
 void SixFrameHandle::RequestSetParamValue(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -581,21 +603,21 @@ void SixFrameHandle::RequestSetParamValue(const std::string &url, ResponseHandle
 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);
+        std::shared_ptr<ParseUrl<PlayBackEvent>> parseImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
         if ("param" == key) {
             if ("enter" == value) {
-                parseyImpl->mData = PlayBackEvent::START;
+                parseImpl->mData = PlayBackEvent::START;
             }
             if ("exit" == value) {
-                parseyImpl->mData = PlayBackEvent::STOP;
+                parseImpl->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);
+    std::shared_ptr<ParseUrl<PlayBackEvent>> parseImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
-    parseyImpl->mData = PlayBackEvent::END;
+    parseImpl->mData = PlayBackEvent::END;
     ExtractParamsFromUrl(url, parseFunc, parse);
-    return parseyImpl->mData;
+    return parseImpl->mData;
 }
 void SixFrameHandle::RequestPlayback(const std::string &url, ResponseHandle responseHandle, void *context)
 {
@@ -641,15 +663,15 @@ void SixFrameHandle::RequestUpload(const std::string &url, ResponseHandle respon
 std::string inline SixFrameHandle::RequestGetThumbnailParse(const std::string &url)
 {
     auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
-        std::shared_ptr<ParseUrl<std::string>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
+        std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
         if ("file" == key) {
-            parseyImpl->mData = value;
+            parseImpl->mData = value;
         }
     };
     std::shared_ptr<VParseUrl> parse = std::make_shared<ParseUrl<std::string>>();
-    std::shared_ptr<ParseUrl<std::string>> parseyImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
+    std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
     ExtractParamsFromUrl(url, parseFunc, parse);
-    return parseyImpl->mData;
+    return parseImpl->mData;
 }
 void SixFrameHandle::RequestGetThumbnail(const std::string &url, ResponseHandle responseHandle, void *context)
 {

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

@@ -68,8 +68,9 @@ private:
     void ResponseGetSdCardInfo(cJSON *result, const AppGetSdCardInfo &param);
     void RequestGetBatteryInfo(const std::string &url, ResponseHandle responseHandle, void *context);
     void ResponseGetBatteryInfo(cJSON *result, const AppGetBatteryInfo &param);
+    AppParamValue RequestParamValueParse(const std::string &url);
     void RequestGetParamValue(const std::string &url, ResponseHandle responseHandle, void *context);
-    void ResponseGetParamValue(cJSON *result, const AppGetParamValue &param);
+    void ResponseGetParamValue(cJSON *result, const AppParamValue &param);
     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);

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

@@ -60,7 +60,7 @@ StatusCode TestMissionStateTest::GetBatteryInfo(AppGetBatteryInfo &param)
     }
     return code;
 }
-StatusCode TestMissionStateTest::GetParamValue(AppGetParamValue &param)
+StatusCode TestMissionStateTest::GetParamValue(AppParamValue &param)
 {
     LogInfo("TestMissionStateTest::GetParamValue\n");
     StatusCode code = GetParamValueTrace(param);

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 GetParamValue(AppGetParamValue &param) override;
+    StatusCode GetParamValue(AppParamValue &param) override;
     StatusCode GetCapability(AppGetCapability &param) override;
     StatusCode GetLockVideoStatus(LockVideoStatus &param) override;
     StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param) override;

test/middleware/AppManager/src/AppManager_Test.cpp

@@ -57,7 +57,7 @@ TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_Demo0)
     IAppManager::GetInstance()->Init(mAppParam);
     IAppManager::GetInstance()->SetAppMonitor(monitor);
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    std::this_thread::sleep_for(std::chrono::milliseconds(20000));
+    std::this_thread::sleep_for(std::chrono::milliseconds(200000));
     IAppManager::GetInstance()->UnInit();
 }
 // ../output_files/test/bin/AppManagerTest --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_Demo

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

@@ -84,7 +84,7 @@ StatusCode AppMonitorTrace::GetBatteryInfoTrace(AppGetBatteryInfo &param)
     LogInfo("AppMonitorTrace::GetBatteryInfoTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
-StatusCode AppMonitorTest::GetParamValue(AppGetParamValue &param)
+StatusCode AppMonitorTest::GetParamValue(AppParamValue &param)
 {
     LogInfo("AppMonitorTest::GetParamValue\n");
     StatusCode code = GetParamValueTrace(param);
@@ -93,7 +93,7 @@ StatusCode AppMonitorTest::GetParamValue(AppGetParamValue &param)
     }
     return code;
 }
-StatusCode AppMonitorTrace::GetParamValueTrace(AppGetParamValue &param)
+StatusCode AppMonitorTrace::GetParamValueTrace(AppParamValue &param)
 {
     LogInfo("AppMonitorTrace::GetParamValueTrace\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);

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

@@ -28,7 +28,7 @@ protected:
     virtual StatusCode GetMediaInfoTrace(AppGetMeidaInfo &param);
     virtual StatusCode GetSdCardInfoTrace(AppGetSdCardInfo &param);
     virtual StatusCode GetBatteryInfoTrace(AppGetBatteryInfo &param);
-    virtual StatusCode GetParamValueTrace(AppGetParamValue &param);
+    virtual StatusCode GetParamValueTrace(AppParamValue &param);
     virtual StatusCode GetCapabilityTrace(AppGetCapability &param);
     virtual StatusCode GetLockVideoStatusTrace(LockVideoStatus &param);
     virtual StatusCode GetStorageInfoTrace(std::vector<AppGetStorageInfo> &param);
@@ -50,7 +50,7 @@ public:
     StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
     StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
     StatusCode GetBatteryInfo(AppGetBatteryInfo &param) override;
-    StatusCode GetParamValue(AppGetParamValue &param) override;
+    StatusCode GetParamValue(AppParamValue &param) override;
     StatusCode GetCapability(AppGetCapability &param) override;
     StatusCode GetLockVideoStatus(LockVideoStatus &param) override;
     StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param) override;
@@ -72,7 +72,7 @@ public:
     MOCK_METHOD1(GetMediaInfoTrace, StatusCode(AppGetMeidaInfo &));
     MOCK_METHOD1(GetSdCardInfoTrace, StatusCode(AppGetSdCardInfo &));
     MOCK_METHOD1(GetBatteryInfoTrace, StatusCode(AppGetBatteryInfo &));
-    MOCK_METHOD1(GetParamValueTrace, StatusCode(AppGetParamValue &));
+    MOCK_METHOD1(GetParamValueTrace, StatusCode(AppParamValue &));
     MOCK_METHOD1(GetCapabilityTrace, StatusCode(AppGetCapability &));
     MOCK_METHOD1(GetLockVideoStatusTrace, StatusCode(LockVideoStatus &));
     MOCK_METHOD1(GetStorageInfoTrace, StatusCode(std::vector<AppGetStorageInfo> &));