Backup:AppManager module.

middleware/AppManager/include/IAppManager.h

@@ -31,6 +31,37 @@ 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
+};
 typedef struct app_get_product_info
 {
     app_get_product_info() {}
@@ -59,18 +90,6 @@ typedef struct app_get_media_info
     std::string mTransport;
     int mPort;
 } AppGetMeidaInfo;
-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
-};
 typedef struct app_get_sd_card_info
 {
     app_get_sd_card_info()
@@ -83,12 +102,6 @@ typedef struct app_get_sd_card_info
     int mFree;
     int mTotal;
 } AppGetSdCardInfo;
-enum class ChargeStatus
-{
-    UNCHARGED = 0,
-    CHARGING,
-    END
-};
 typedef struct app_get_battery_info
 {
     app_get_battery_info()
@@ -99,6 +112,47 @@ typedef struct app_get_battery_info
     int mCapacity;
     ChargeStatus mChargeStatus;
 } AppGetBatteryInfo;
+typedef struct app_get_param_value
+{
+    app_get_param_value()
+    {
+        mCapacity = 0;
+        mChargeStatus = ChargeStatus::END;
+    }
+    int mCapacity;
+    ChargeStatus mChargeStatus;
+} AppGetParamValue;
+typedef struct app_get_capability
+{
+    app_get_capability()
+    {
+        mCapacity = 0;
+        mChargeStatus = ChargeStatus::END;
+    }
+    int mCapacity;
+    ChargeStatus mChargeStatus;
+} AppGetCapability;
+typedef struct app_get_storage_info
+{
+    app_get_storage_info()
+    {
+        mIndex = -1;
+        mType = StorageType::END;
+        mFree = 0;
+        mTotal = 0;
+    }
+    int mIndex;
+    StorageType mType;
+    std::string mName;
+    int mFree;
+    int mTotal;
+} AppGetStorageInfo;
+typedef struct app_set_param_value
+{
+    app_set_param_value() { mValue = -1; }
+    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,
@@ -133,8 +187,14 @@ public:
     virtual StatusCode GetMediaInfo(AppGetMeidaInfo &param);
     virtual StatusCode GetSdCardInfo(AppGetSdCardInfo &param);
     virtual StatusCode GetBatteryInfo(AppGetBatteryInfo &param);
+    virtual StatusCode GetParamValue(AppGetParamValue &param);
+    virtual StatusCode GetCapability(AppGetCapability &param);
+    virtual StatusCode GetLockVideoStatus(LockVideoStatus &param);
+    virtual StatusCode GetStorageInfo(std::vector<AppGetStorageInfo> &param);
     virtual StatusCode SetDateTime(AppSetDateTime &param);
     virtual StatusCode SetTimeZone(const unsigned int &zone);
+    virtual StatusCode SetParamValue(AppSetParamValue &param);
+    virtual StatusCode EnterRecorder(void);
     virtual StatusCode UploadFile(AppUploadFile &param);
 };
 typedef struct app_param

middleware/AppManager/src/IAppManager.cpp

@@ -31,8 +31,29 @@ StatusCode VAppMonitor::GetBatteryInfo(AppGetBatteryInfo &param)
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode VAppMonitor::GetParamValue(AppGetParamValue &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::SetDateTime(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)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode VAppMonitor::EnterRecorder(void) { 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

@@ -26,8 +26,14 @@ const char *APP_GET_DEVICE_ATTR = "/app/getdeviceattr";
 const char *APP_GET_MEDIA_INFO = "/app/getmediainfo";
 const char *APP_GET_SD_CARD_INFO = "/app/getsdinfo";
 const char *APP_GET_BATTERY_INFO = "/app/getbatteryinfo";
+const char *APP_GET_PARAM_VALUE = "/app/getparamvalue";
+const char *APP_GET_CAPABILITY = "/app/capability";
+const char *APP_GET_LOCK_VIDEO_STATUS = "/app/getlockvideostatus";
+const char *APP_GET_STORAGE_INFO = "/app/getstorageinfo";
 const char *APP_SET_DATE_TIME = "/app/setsystime";
 const char *APP_SET_TIME_ZONE = "/app/settimezone";
+const char *APP_SET_PARAM_VALUE = "/app/setparamvalue";
+const char *APP_ENTER_RECORDER = "/app/enterrecorder";
 const char *APP_UPLOAD_FILE = "/upload";
 constexpr bool SET_REQUEST_RESPONSE = true;
 SixFrameHandle::SixFrameHandle()
@@ -38,8 +44,13 @@ SixFrameHandle::SixFrameHandle()
     mResquesHandleFunc[APP_GET_MEDIA_INFO] = std::bind(&SixFrameHandle::RequestGetMediaInfo, this, _1, _2, _3);
     mResquesHandleFunc[APP_GET_SD_CARD_INFO] = std::bind(&SixFrameHandle::RequestGetSdCardInfo, this, _1, _2, _3);
     mResquesHandleFunc[APP_GET_BATTERY_INFO] = std::bind(&SixFrameHandle::RequestGetBatteryInfo, this, _1, _2, _3);
+    mResquesHandleFunc[APP_GET_PARAM_VALUE] = std::bind(&SixFrameHandle::RequestGetParamValue, this, _1, _2, _3);
+    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_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_ENTER_RECORDER] = std::bind(&SixFrameHandle::RequestEnterRecorder, 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, _);
 }
@@ -98,6 +109,11 @@ void SixFrameHandle::DoNothing(const std::string &url, ResponseHandle responseHa
     // responseHandle("Unknown command.", context);
     char *resultStr = nullptr;
     cJSON *result = MakeResponseResult(ResposeResult::FAILED);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
     free(resultStr);
@@ -110,6 +126,11 @@ void SixFrameHandle::RequestGetProductInfo(const std::string &url, ResponseHandl
     AppGetProductInfo param;
     mAppMonitor->GetProductInfo(param);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     ResponseGetProductInfo(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
@@ -132,6 +153,11 @@ void SixFrameHandle::RequestGetDeviceAttr(const std::string &url, ResponseHandle
     AppGetDeviceAttr param;
     mAppMonitor->GetDeviceAttr(param);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     ResponseGetDeviceAttr(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
@@ -159,6 +185,11 @@ void SixFrameHandle::RequestGetMediaInfo(const std::string &url, ResponseHandle
     AppGetMeidaInfo param;
     mAppMonitor->GetMediaInfo(param);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     ResponseGetMediaInfo(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
@@ -181,6 +212,11 @@ void SixFrameHandle::RequestGetSdCardInfo(const std::string &url, ResponseHandle
     AppGetSdCardInfo param;
     mAppMonitor->GetSdCardInfo(param);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     ResponseGetSdCardInfo(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
@@ -202,6 +238,11 @@ void SixFrameHandle::RequestGetBatteryInfo(const std::string &url, ResponseHandl
     AppGetBatteryInfo param;
     mAppMonitor->GetBatteryInfo(param);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     ResponseGetBatteryInfo(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
@@ -215,6 +256,119 @@ void inline SixFrameHandle::ResponseGetBatteryInfo(cJSON *result, const AppGetBa
     cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
     cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
 }
+void SixFrameHandle::RequestGetParamValue(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetParamValue.\n");
+    char *resultStr = nullptr;
+    AppGetParamValue param;
+    mAppMonitor->GetParamValue(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    ResponseGetParamValue(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppGetParamValue &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
+    cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
+}
+void SixFrameHandle::RequestGetCapability(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetCapability.\n");
+    char *resultStr = nullptr;
+    AppGetCapability param;
+    mAppMonitor->GetCapability(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    ResponseGetCapability(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetCapability(cJSON *result, const AppGetCapability &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddNumberToObject(info, "charge", static_cast<int>(param.mChargeStatus));
+    cJSON_AddNumberToObject(info, "capacity", param.mCapacity);
+}
+void SixFrameHandle::RequestGetLockVideoStatus(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetLockVideoStatus.\n");
+    char *resultStr = nullptr;
+    LockVideoStatus param;
+    mAppMonitor->GetLockVideoStatus(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    ResponseGetLockVideoStatus(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetLockVideoStatus(cJSON *result, const LockVideoStatus &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddNumberToObject(info, "status", static_cast<int>(param));
+}
+void SixFrameHandle::RequestGetStorageInfo(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetStorageInfo.\n");
+    char *resultStr = nullptr;
+    std::vector<AppGetStorageInfo> param;
+    mAppMonitor->GetStorageInfo(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    ResponseGetStorageInfo(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetStorageInfo(cJSON *result, const std::vector<AppGetStorageInfo> &param)
+{
+    cJSON *info = cJSON_CreateArray();
+    if (nullptr == info) {
+        LogError("cJSON_CreateArray failed.\n");
+        return;
+    }
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info);
+    for (const auto &storageInfo : param) {
+        cJSON *storage = nullptr;
+        storage = cJSON_CreateObject();
+        if (nullptr != storage) {
+            cJSON_AddItemToArray(info, storage);
+            cJSON_AddNumberToObject(storage, "index", static_cast<int>(storageInfo.mIndex));
+            cJSON_AddStringToObject(storage, "name", storageInfo.mName.c_str());
+            cJSON_AddNumberToObject(storage, "type", static_cast<int>(storageInfo.mType));
+            cJSON_AddNumberToObject(storage, "free", storageInfo.mFree);
+            cJSON_AddNumberToObject(storage, "total", storageInfo.mTotal);
+        }
+    }
+}
 AppSetDateTime inline SixFrameHandle::RequestSetDateTimeParse(const std::string &url)
 {
     auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr<VParseUrl> &parse) {
@@ -251,6 +405,11 @@ void SixFrameHandle::RequestSetDateTime(const std::string &url, ResponseHandle r
     AppSetDateTime param = RequestSetDateTimeParse(url);
     mAppMonitor->SetDateTime(param);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL, SET_REQUEST_RESPONSE);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     // ResponseGetBatteryInfo(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
@@ -277,17 +436,81 @@ int inline SixFrameHandle::RequestSetTimeZoneParse(const std::string &url)
 }
 void SixFrameHandle::RequestSetTimeZone(const std::string &url, ResponseHandle responseHandle, void *context)
 {
-    LogInfo("RequestGetDeviceAttr.\n");
+    LogInfo("RequestSetTimeZone.\n");
     char *resultStr = nullptr;
     int zone = RequestSetTimeZoneParse(url);
     mAppMonitor->SetTimeZone(zone);
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL, SET_REQUEST_RESPONSE);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     // ResponseGetBatteryInfo(result, param);
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
     free(resultStr);
     cJSON_Delete(result);
 }
+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::dynamic_pointer_cast<ParseUrl<AppSetParamValue>>(parse);
+        if ("switchcam" == key) {
+            parseyImpl->mData.mName = "switchcam";
+            parseyImpl->mData.mValue = std::stoi(value);
+        }
+        if ("rec" == key) {
+            parseyImpl->mData.mName = "rec";
+            parseyImpl->mData.mValue = std::stoi(value);
+        }
+        if ("mic" == key) {
+            parseyImpl->mData.mName = "mic";
+            parseyImpl->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::dynamic_pointer_cast<ParseUrl<AppSetParamValue>>(parse);
+    return parseyImpl->mData;
+}
+void SixFrameHandle::RequestSetParamValue(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestSetParamValue.\n");
+    char *resultStr = nullptr;
+    AppSetParamValue value = RequestSetParamValueParse(url);
+    mAppMonitor->SetParamValue(value);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL, SET_REQUEST_RESPONSE);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    // ResponseGetBatteryInfo(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void SixFrameHandle::RequestEnterRecorder(const std::string &url, ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestEnterRecorder.\n");
+    char *resultStr = nullptr;
+    mAppMonitor->EnterRecorder();
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
 void SixFrameHandle::RequestUpload(const std::string &url, ResponseHandle responseHandle, void *context)
 {
     LogInfo("RequestUpload.\n");
@@ -295,6 +518,11 @@ void SixFrameHandle::RequestUpload(const std::string &url, ResponseHandle respon
     AppUploadFile info("path", UploadCommand::UPGRADE_CPU);
     mAppMonitor->UploadFile(info);
     cJSON *result = MakeResponseResult(info.mResult);
+    if (nullptr == result) {
+        LogError("MakeResponseResult failed.\n");
+        responseHandle("Device run out of memory.", context);
+        return;
+    }
     resultStr = cJSON_Print(result);
     responseHandle(resultStr, context);
     free(resultStr);
@@ -304,9 +532,13 @@ cJSON *SixFrameHandle::MakeResponseResult(const ResposeResult result, const bool
 {
     const char *RESPONSE_RESULT = "result";
     cJSON *resultCJSON = cJSON_CreateObject();
+    if (nullptr == resultCJSON) {
+        LogError("cJSON_CreateObject failed.\n");
+        goto END;
+    }
     cJSON_AddNumberToObject(resultCJSON, RESPONSE_RESULT, static_cast<int>(result));
     if (false == requestSet) {
-        return resultCJSON;
+        goto END;
     }
     if (ResposeResult::SUCCESSFUL == result) {
         cJSON_AddStringToObject(resultCJSON, CJSON_INFO_STRING, "set success.");
@@ -314,6 +546,7 @@ cJSON *SixFrameHandle::MakeResponseResult(const ResposeResult result, const bool
     else {
         cJSON_AddStringToObject(resultCJSON, CJSON_INFO_STRING, "set failed."); // TODO: what the failed string is?
     }
+END:
     return resultCJSON;
 }
 void SixFrameHandle::SetAppMonitor(std::shared_ptr<VAppMonitor> &monitor)

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

@@ -30,6 +30,7 @@ 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
 {
@@ -41,7 +42,6 @@ public:
 public:
     T mData;
 };
-using ParseUrlResultFunc = void(const std::string &, const std::string &, std::shared_ptr<VParseUrl> &);
 class SixFrameHandle : public IAppProtocolHandle
 {
 public:
@@ -68,10 +68,21 @@ 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);
+    void RequestGetParamValue(const std::string &url, ResponseHandle responseHandle, void *context);
+    void ResponseGetParamValue(cJSON *result, const AppGetParamValue &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);
+    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);
     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);
+    void RequestEnterRecorder(const std::string &url, ResponseHandle responseHandle, void *context);
     void RequestUpload(const std::string &url, ResponseHandle responseHandle, void *context);
 
 private: