Add:SixFrame protocol code.

middleware/AppManager/include/IAppManager.h

@@ -39,6 +39,43 @@ typedef struct app_get_product_info
     std::string mSoc;
     std::string mSp;
 } AppGetProductInfo;
+typedef struct app_get_device_attr
+{
+    app_get_device_attr() {}
+    std::string mUUID;
+    std::string mSoftVersion;
+    std::string mOtaVersion;
+    std::string mHardwareVersion;
+    std::string mSSID;
+    std::string mBSSID;
+    std::string mCameraNumber;
+    std::string mCurrentCameraID;
+    std::string mWifiReboot;
+} AppGetDeviceAttr;
+typedef struct app_get_media_info
+{
+    app_get_media_info() { mPort = -1; }
+    std::string mRtspUrl;
+    std::string mTransport;
+    int mPort;
+} AppGetMeidaInfo;
+enum class SdCardStatus
+{
+    UNMOUNT = 0,
+    END
+};
+typedef struct app_get_sd_card_info
+{
+    app_get_sd_card_info()
+    {
+        mStatus = SdCardStatus::END;
+        mFree = 0;
+        mTotal = 0;
+    }
+    SdCardStatus mStatus;
+    int mFree;
+    int mTotal;
+} AppGetSdCardInfo;
 typedef struct app_upload_file
 {
     app_upload_file(const std::string filePath, const UploadCommand command) : mFilePath(filePath), mCommand(command)
@@ -55,6 +92,9 @@ public:
     VAppMonitor() = default;
     virtual ~VAppMonitor() = default;
     virtual StatusCode GetProductInfo(AppGetProductInfo &param);
+    virtual StatusCode GetDeviceAttr(AppGetDeviceAttr &param);
+    virtual StatusCode GetMediaInfo(AppGetMeidaInfo &param);
+    virtual StatusCode GetSdCardInfo(AppGetSdCardInfo &param);
     virtual StatusCode UploadFile(AppUploadFile &param);
 };
 typedef struct app_param

middleware/AppManager/src/IAppManager.cpp

@@ -14,12 +14,26 @@
  */
 #include "IAppManager.h"
 #include "ILog.h"
-
+StatusCode inline VAppMonitor::GetProductInfo(AppGetProductInfo &param)
-StatusCode VAppMonitor::GetProductInfo(AppGetProductInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode inline VAppMonitor::GetDeviceAttr(AppGetDeviceAttr &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode inline VAppMonitor::GetMediaInfo(AppGetMeidaInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode inline VAppMonitor::GetSdCardInfo(AppGetSdCardInfo &param)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode inline VAppMonitor::UploadFile(AppUploadFile &param)
 {
     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)
 {
     static auto instance = std::make_shared<IAppManager>();

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

@@ -20,12 +20,19 @@ using std::placeholders::_1;
 using std::placeholders::_2;
 using std::placeholders::_3;
 // using std::placeholders::_4;
+const char *CJSON_INFO_STRING = "info";
 const char *APP_GET_PRODUCT_INFO = "/app/getproductinfo";
+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_UPLOAD_FILE = "/upload";
 SixFrameHandle::SixFrameHandle()
 {
     mAppMonitor = std::make_shared<VAppMonitor>();
     mResquesHandleFunc[APP_GET_PRODUCT_INFO] = std::bind(&SixFrameHandle::RequestGetProductInfo, this, _1, _2, _3);
+    mResquesHandleFunc[APP_GET_DEVICE_ATTR] = std::bind(&SixFrameHandle::RequestGetDeviceAttr, this, _1, _2, _3);
+    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_UPLOAD_FILE] = std::bind(&SixFrameHandle::RequestUpload, this, _1, _2, _3);
     // mResquesHandleFunc["favicon.ico"] = std::bind(&SixFrameHandle::DoNothing, this, _1, _2, _3);
 }
@@ -91,12 +98,84 @@ void SixFrameHandle::RequestGetProductInfo(std::multimap<std::string, std::strin
     char *resultStr = nullptr;
     cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
     resultStr = cJSON_Print(result);
-    AppGetProductInfo info;
+    AppGetProductInfo param;
-    mAppMonitor->GetProductInfo(info);
+    mAppMonitor->GetProductInfo(param);
     responseHandle(resultStr, context);
     free(resultStr);
     cJSON_Delete(result);
 }
+void SixFrameHandle::RequestGetDeviceAttr(std::multimap<std::string, std::string> &paramsMap,
+                                          ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetDeviceAttr.\n");
+    char *resultStr = nullptr;
+    AppGetDeviceAttr param;
+    mAppMonitor->GetDeviceAttr(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    ResponseGetDeviceAttr(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetDeviceAttr(cJSON *result, const AppGetDeviceAttr &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddStringToObject(info, "uuid", param.mUUID.c_str());
+    cJSON_AddStringToObject(info, "softver", param.mSoftVersion.c_str());
+    cJSON_AddStringToObject(info, "otaver", param.mOtaVersion.c_str());
+    cJSON_AddStringToObject(info, "hwver", param.mHardwareVersion.c_str());
+    cJSON_AddStringToObject(info, "ssid", param.mSSID.c_str());
+    cJSON_AddStringToObject(info, "bssid", param.mBSSID.c_str());
+    cJSON_AddStringToObject(info, "camnum", param.mCameraNumber.c_str());
+    cJSON_AddStringToObject(info, "curcamid", param.mCurrentCameraID.c_str());
+    cJSON_AddStringToObject(info, "wifireboot", param.mWifiReboot.c_str());
+}
+void SixFrameHandle::RequestGetMediaInfo(std::multimap<std::string, std::string> &paramsMap,
+                                         ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetDeviceAttr.\n");
+    char *resultStr = nullptr;
+    AppGetMeidaInfo param;
+    mAppMonitor->GetMediaInfo(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    ResponseGetMediaInfo(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetMediaInfo(cJSON *result, const AppGetMeidaInfo &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddStringToObject(info, "uuid", param.mRtspUrl.c_str());
+    cJSON_AddStringToObject(info, "softver", param.mTransport.c_str());
+    cJSON_AddNumberToObject(info, "otaver", param.mPort);
+}
+void SixFrameHandle::RequestGetSdCardInfo(std::multimap<std::string, std::string> &paramsMap,
+                                          ResponseHandle responseHandle, void *context)
+{
+    LogInfo("RequestGetDeviceAttr.\n");
+    char *resultStr = nullptr;
+    AppGetSdCardInfo param;
+    mAppMonitor->GetSdCardInfo(param);
+    cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL);
+    ResponseGetSdCardInfo(result, param);
+    resultStr = cJSON_Print(result);
+    responseHandle(resultStr, context);
+    free(resultStr);
+    cJSON_Delete(result);
+}
+void inline SixFrameHandle::ResponseGetSdCardInfo(cJSON *result, const AppGetSdCardInfo &param)
+{
+    cJSON *info = nullptr;
+    cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject());
+    cJSON_AddNumberToObject(info, "status", static_cast<int>(param.mStatus));
+    cJSON_AddNumberToObject(info, "free", param.mFree);
+    cJSON_AddNumberToObject(info, "total", param.mTotal);
+}
 void SixFrameHandle::RequestUpload(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle,
                                    void *context)
 {

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

@@ -41,6 +41,15 @@ private:
     void DoNothing(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle, void *context);
     void RequestGetProductInfo(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle,
                                void *context);
+    void RequestGetDeviceAttr(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle,
+                              void *context);
+    void ResponseGetDeviceAttr(cJSON *result, const AppGetDeviceAttr &param);
+    void RequestGetMediaInfo(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle,
+                             void *context);
+    void ResponseGetMediaInfo(cJSON *result, const AppGetMeidaInfo &param);
+    void RequestGetSdCardInfo(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle,
+                              void *context);
+    void ResponseGetSdCardInfo(cJSON *result, const AppGetSdCardInfo &param);
     void RequestUpload(std::multimap<std::string, std::string> &paramsMap, ResponseHandle responseHandle,
                        void *context);
 

test/middleware/AppManager/src/AppManager_Test.cpp

@@ -73,4 +73,40 @@ TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_Upload)
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     IAppManager::GetInstance()->UnInit();
 }
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetDeviceAttr
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetDeviceAttr)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetDeviceAttr();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetMediaInfo
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetMediaInfo)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetMediaInfo();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
+// ../output_files/test/bin/AppManagerTest
+// --gtest_filter=AppManagerTest.INTEGRATION_AppManager_EXAMPLE_AUTO_GetSdCardInfo
+TEST_F(AppManagerTest, INTEGRATION_AppManager_EXAMPLE_AUTO_GetSdCardInfo)
+{
+    std::shared_ptr<VAppMonitor> monitor = AppManagerTestTool::MakeMonitorMock();
+    IAppManager::GetInstance()->Init(mAppParam);
+    IAppManager::GetInstance()->SetAppMonitor(monitor);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MockGetSdCardInfo();
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    IAppManager::GetInstance()->UnInit();
+}
 } // namespace AppManagerTest

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

@@ -27,6 +27,9 @@ public:
 
 protected:
     void MockGetProductInfo(void);
+    void MockGetDeviceAttr(void);
+    void MockGetMediaInfo(void);
+    void MockGetSdCardInfo(void);
     void MockUploadFiles(void);
 
 private:

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

@@ -18,8 +18,10 @@
 #include "AppMonitorMock.h"
 #include "ILog.h"
 #include "ServersMock.h"
+constexpr int ONLY_BE_CALLED_ONCE = 1;
 void AppManagerTestTool::Init(void)
 {
+    ServersMock::GetInstance()->Init();
     mAppManagerMock = std::make_shared<AppManagerMock>();
     AppManagerMockInit(mAppManagerMock);
     std::shared_ptr<AppManagerMock> mock = std::dynamic_pointer_cast<AppManagerMock>(mAppManagerMock);
@@ -27,6 +29,7 @@ void AppManagerTestTool::Init(void)
 }
 void AppManagerTestTool::UnInit(void)
 {
+    ServersMock::GetInstance()->UnInit();
     mAppManagerMock.reset();
     mAppMonitorMock.reset();
     CancelOverrideAppManagerMakePtrObject();
@@ -36,6 +39,42 @@ void AppManagerTestTool::MockGetProductInfo(void)
     //
     ServersMock::GetInstance()->MockGetProductInfo();
 }
+void AppManagerTestTool::MockGetDeviceAttr(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (!mock) {
+        LogError("vMock error.\n");
+        return;
+    }
+    EXPECT_CALL(*mock.get(), GetDeviceAttrTrace(_))
+        .Times(ONLY_BE_CALLED_ONCE)
+        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    ServersMock::GetInstance()->MockGetDeviceAttr();
+}
+void AppManagerTestTool::MockGetMediaInfo(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (!mock) {
+        LogError("vMock error.\n");
+        return;
+    }
+    EXPECT_CALL(*mock.get(), GetMediaInfoTrace(_))
+        .Times(ONLY_BE_CALLED_ONCE)
+        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    ServersMock::GetInstance()->MockGetMediaInfo();
+}
+void AppManagerTestTool::MockGetSdCardInfo(void)
+{
+    std::shared_ptr<AppMonitorMock> mock = std::dynamic_pointer_cast<AppMonitorMock>(mAppMonitorMock);
+    if (!mock) {
+        LogError("vMock error.\n");
+        return;
+    }
+    EXPECT_CALL(*mock.get(), GetSdCardInfoTrace(_))
+        .Times(ONLY_BE_CALLED_ONCE)
+        .WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    ServersMock::GetInstance()->MockGetSdCardInfo();
+}
 void AppManagerTestTool::MockUploadFiles(void)
 {
     //
@@ -53,7 +92,6 @@ void AppManagerTestTool::AppManagerMockInit(std::shared_ptr<IAppManager> &vMock)
         mAppMonitorMock = std::dynamic_pointer_cast<AppMonitorMock>(monitor);
         AppManagerTestTool::AppMonitorInit(mAppMonitorMock);
     };
-    constexpr int ONLY_BE_CALLED_ONCE = 1;
     EXPECT_CALL(*mock.get(), SetAppMonitorTrace(_))
         .Times(ONLY_BE_CALLED_ONCE)
         .WillOnce(DoAll(WithArgs<0>(Invoke(getAppMonitor)), Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
@@ -63,6 +101,12 @@ std::shared_ptr<VAppMonitor> AppManagerTestTool::MakeMonitorMock(void)
     auto monitor = std::make_shared<AppMonitorMock>();
     EXPECT_CALL(*monitor.get(), GetProductInfoTrace(_))
         .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    EXPECT_CALL(*monitor.get(), GetDeviceAttrTrace(_))
+        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    EXPECT_CALL(*monitor.get(), GetMediaInfoTrace(_))
+        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
+    EXPECT_CALL(*monitor.get(), GetSdCardInfoTrace(_))
+        .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     EXPECT_CALL(*monitor.get(), UploadFileTrace(_))
         .WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
     return monitor;

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

@@ -23,6 +23,53 @@ StatusCode AppMonitorTest::GetProductInfo(AppGetProductInfo &param)
     }
     return code;
 }
+StatusCode AppMonitorTest::GetProductInfoTrace(AppGetProductInfo &param)
+{
+    LogInfo("AppMonitorTest::GetProductInfoTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetDeviceAttr(AppGetDeviceAttr &param)
+{
+    LogInfo("AppMonitorTest::GetDeviceAttr\n");
+    StatusCode code = GetDeviceAttrTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetDeviceAttr(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTest::GetDeviceAttrTrace(AppGetDeviceAttr &param)
+{
+    LogInfo("AppMonitorTest::GetDeviceAttrTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetMediaInfo(AppGetMeidaInfo &param)
+{
+    LogInfo("AppMonitorTest::GetMediaInfo\n");
+    StatusCode code = GetMediaInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetMediaInfo(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTest::GetMediaInfoTrace(AppGetMeidaInfo &param)
+{
+    LogInfo("AppMonitorTest::GetMediaInfoTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+StatusCode AppMonitorTest::GetSdCardInfo(AppGetSdCardInfo &param)
+{
+    LogInfo("AppMonitorTest::GetSdCardInfo\n");
+    StatusCode code = GetSdCardInfoTrace(param);
+    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
+        return VAppMonitor::GetSdCardInfo(param);
+    }
+    return code;
+}
+StatusCode AppMonitorTest::GetSdCardInfoTrace(AppGetSdCardInfo &param)
+{
+    LogInfo("AppMonitorTest::GetSdCardInfoTrace\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
 StatusCode AppMonitorTest::UploadFile(AppUploadFile &param)
 {
     LogInfo("AppMonitorTest::UploadFile\n");
@@ -32,11 +79,6 @@ StatusCode AppMonitorTest::UploadFile(AppUploadFile &param)
     }
     return code;
 }
-StatusCode AppMonitorTest::GetProductInfoTrace(AppGetProductInfo &param)
-{
-    LogInfo("AppMonitorTest::GetProductInfoTrace\n");
-    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
-}
 StatusCode AppMonitorTest::UploadFileTrace(AppUploadFile &param)
 {
     LogInfo("AppMonitorTest::UploadFileTrace\n");

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

@@ -22,10 +22,16 @@ public:
     AppMonitorTest() = default;
     virtual ~AppMonitorTest() = default;
     StatusCode GetProductInfo(AppGetProductInfo &param) override;
+    StatusCode GetDeviceAttr(AppGetDeviceAttr &param) override;
+    StatusCode GetMediaInfo(AppGetMeidaInfo &param) override;
+    StatusCode GetSdCardInfo(AppGetSdCardInfo &param) override;
     StatusCode UploadFile(AppUploadFile &param) override;
 
 protected:
     virtual StatusCode GetProductInfoTrace(AppGetProductInfo &param);
+    virtual StatusCode GetDeviceAttrTrace(AppGetDeviceAttr &param);
+    virtual StatusCode GetMediaInfoTrace(AppGetMeidaInfo &param);
+    virtual StatusCode GetSdCardInfoTrace(AppGetSdCardInfo &param);
     virtual StatusCode UploadFileTrace(AppUploadFile &param);
 };
 class AppMonitorMock : public AppMonitorTest
@@ -34,6 +40,9 @@ public:
     AppMonitorMock() = default;
     virtual ~AppMonitorMock() = default;
     MOCK_METHOD1(GetProductInfoTrace, StatusCode(AppGetProductInfo &));
+    MOCK_METHOD1(GetDeviceAttrTrace, StatusCode(AppGetDeviceAttr &));
+    MOCK_METHOD1(GetMediaInfoTrace, StatusCode(AppGetMeidaInfo &));
+    MOCK_METHOD1(GetSdCardInfoTrace, StatusCode(AppGetSdCardInfo &));
     MOCK_METHOD1(UploadFileTrace, StatusCode(AppUploadFile &));
 };
 #endif

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

@@ -17,6 +17,10 @@
 #include "servers.h"
 #include <cstring>
 extern const char *APP_GET_PRODUCT_INFO;
+extern const char *APP_GET_DEVICE_ATTR;
+extern const char *APP_UPLOAD_FILE;
+extern const char *APP_GET_MEDIA_INFO;
+extern const char *APP_GET_SD_CARD_INFO;
 std::shared_ptr<ServersMock> &ServersMock::GetInstance(std::shared_ptr<ServersMock> *impl)
 {
     static auto instance = std::make_shared<ServersMock>();
@@ -36,14 +40,21 @@ ServersMock::ServersMock()
     //
     mServerUrl = APP_MANAGER_HTTP_SERVER_IP ":" + std::to_string(APP_MANAGER_HTTP_SERVER_PORT);
 }
-void ServersMock::MockGetProductInfo(void)
+void ServersMock::Init(void)
 {
     ServerParam init = {
         .logFlag = LOG_FLAG_ENABLE,
         .sslVerifyFlag = SSL_VERIFY_DISABLE,
     };
     ServersInit(init);
-    LogInfo("servers test start.\n");
+}
+void ServersMock::UnInit(void)
+{
+    //
+}
+void ServersMock::MockGetProductInfo(void)
+{
+    LogInfo("APP_GET_PRODUCT_INFO test start.\n");
     std::string mockRequest = mServerUrl + APP_GET_PRODUCT_INFO;
     ServerHttp *http = NewServersHttp(mockRequest.c_str());
     if (http) {
@@ -58,18 +69,64 @@ void ServersMock::MockGetProductInfo(void)
         DeleteServersHttp(http);
     }
 }
+void ServersMock::MockGetDeviceAttr(void)
+{
+    LogInfo("APP_GET_DEVICE_ATTR test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_DEVICE_ATTR;
+    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::MockGetMediaInfo(void)
+{
+    LogInfo("APP_GET_MEDIA_INFO test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_MEDIA_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::MockGetSdCardInfo(void)
+{
+    LogInfo("APP_GET_SD_CARD_INFO test start.\n");
+    std::string mockRequest = mServerUrl + APP_GET_SD_CARD_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);
+    }
+}
 #ifndef PLATFORM_PATH
     #error Add the code in your linux.toolchain.cmake : add_definitions(-DPLATFORM_PATH="${PLATFORM_PATH}")
 #endif
 void ServersMock::MockUploadFiles(void)
 {
-    ServerParam init = {
-        .logFlag = LOG_FLAG_ENABLE,
-        .sslVerifyFlag = SSL_VERIFY_DISABLE,
-    };
-    ServersInit(init);
     LogInfo("servers test start.\n");
-    std::string mockRequest = mServerUrl + "/upload";
+    std::string mockRequest = mServerUrl + APP_UPLOAD_FILE;
     ServerHttp *http = NewServersHttp(mockRequest.c_str());
     if (http) {
         http->filePath = (char *)PLATFORM_PATH "/output_files/test/bin/AppManagerTest";

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

@@ -21,7 +21,12 @@ public:
     ServersMock();
     virtual ~ServersMock() = default;
     static std::shared_ptr<ServersMock> &GetInstance(std::shared_ptr<ServersMock> *impl = nullptr);
+    virtual void Init(void);
+    virtual void UnInit(void);
     virtual void MockGetProductInfo(void);
+    virtual void MockGetDeviceAttr(void);
+    virtual void MockGetMediaInfo(void);
+    virtual void MockGetSdCardInfo(void);
     virtual void MockUploadFiles(void);
 
 private: