Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Improve:SixFrame protocol.

Browse Source
This commit is contained in:
Fancy code 2024-03-26 11:22:28 +08:00
parent 1c41198dc1
commit 2956868344
11 changed files with 94 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
application/MissionManager/src/AppMonitor.cpp
View File

@ -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)

2
application/MissionManager/src/AppMonitor.h
View File

@ -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;

15
middleware/AppManager/include/IAppManager.h
View File

@ -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; }
MicStatus mMicStatus;
} AppGetParamValue;
app_get_param_value()
{
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);

5
middleware/AppManager/src/IAppManager.cpp
View File

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

116
middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.cpp
View File

@ -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;
mAppMonitor->GetParamValue(param);
// AppParamValue appGetValue = RequestParamValueParse(url); // TODO:
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);
if (14 != parseyImpl->mData.length()) {
std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
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 monthStr = parseyImpl->mData.substr(4, 2);
std::string dayStr = parseyImpl->mData.substr(6, 2);
std::string hourStr = parseyImpl->mData.substr(8, 2);
std::string minuteStr = parseyImpl->mData.substr(10, 2);
std::string secondStr = parseyImpl->mData.substr(12, 2);
std::string yearStr = parseImpl->mData.substr(0, 4);
std::string monthStr = parseImpl->mData.substr(4, 2);
std::string dayStr = parseImpl->mData.substr(6, 2);
std::string hourStr = parseImpl->mData.substr(8, 2);
std::string minuteStr = parseImpl->mData.substr(10, 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);
if (2 <= parseyImpl->mData.length()) {
std::shared_ptr<ParseUrl<std::string>> parseImpl = std::dynamic_pointer_cast<ParseUrl<std::string>>(parse);
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";
parseyImpl->mData.mValue = std::stoi(value);
parseImpl->mData.mName = "switchcam";
parseImpl->mData.mValue = std::stoi(value);
}
if ("rec" == key) {
parseyImpl->mData.mName = "rec";
parseyImpl->mData.mValue = std::stoi(value);
parseImpl->mData.mName = "rec";
parseImpl->mData.mValue = std::stoi(value);
}
if ("mic" == key) {
parseyImpl->mData.mName = "mic";
parseyImpl->mData.mValue = std::stoi(value);
parseImpl->mData.mName = "mic";
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);
parseyImpl->mData = PlayBackEvent::END;
std::shared_ptr<ParseUrl<PlayBackEvent>> parseImpl = std::dynamic_pointer_cast<ParseUrl<PlayBackEvent>>(parse);
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)
{

3
middleware/AppManager/src/Protocol/SixFrame/SixFrameHandle.h
View File

@ -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);

2
test/application/MissionManager/tool/src/TestMissionStateMock.cpp
View File

@ -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);

2
test/application/MissionManager/tool/src/TestMissionStateMock.h
View File

@ -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;

2
test/middleware/AppManager/src/AppManager_Test.cpp
View File

@ -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

4
test/middleware/AppManager/tool/src/AppMonitorMock.cpp
View File

@ -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);

6
test/middleware/AppManager/tool/src/AppMonitorMock.h
View File

@ -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> &));