/* * Copyright (c) 2023 Fancy Code. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "SixFrameHandle.h" #include "ILog.h" #include #include #include #include using std::placeholders::_1; using std::placeholders::_2; using std::placeholders::_3; // using std::placeholders::_4; // clang-format off const char *TCP_RESULT_MSGID = "msgid"; const char *CJSON_INFO_STRING = "info"; const char *CJSON_FILES_STRING = "files"; 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_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_GET_FILE_LIST = "/app/getfilelist"; 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_PLAYBACK = "/app/playback"; const char *APP_UPLOAD_FILE = "/upload"; const char *APP_GET_THUMBNAIL = "/app/getthumbnail"; // /app/getparamvalue?param=rec // /app/exitrecorder // clang-format on constexpr bool SET_REQUEST_RESPONSE = true; class CjsonAutoFree { public: CjsonAutoFree(cJSON *json) : mJson(json) { } ~CjsonAutoFree() { if (mJson != nullptr) { cJSON_Delete(mJson); } } private: cJSON *mJson; }; SixFrameHandle::SixFrameHandle() { mAppMonitor = std::make_shared(); 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_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_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[APP_GET_THUMBNAIL] = std::bind(&SixFrameHandle::RequestGetThumbnail, this, _1, _2, _3); // mResquesHandleFunc["favicon.ico"] = std::bind(&SixFrameHandle::DoNothing, this, _1, _2, _); } void SixFrameHandle::RequestHandle(const char *url, const unsigned int &urlLength, ResponseHandle responseHandle, void *context) { const std::string urlStr2 = url; LogInfo("URL = %s\n", urlStr2.c_str()); size_t queryStartPos = urlStr2.find('?'); std::string command = ""; if (queryStartPos != std::string::npos && queryStartPos + 1 < urlStr2.length()) { command = urlStr2.substr(0, queryStartPos); } else { command = urlStr2.substr(0, urlStr2.length()); } LogInfo("command = %s\n", command.c_str()); RequestHandle2(command, urlStr2, responseHandle, context); } void SixFrameHandle::RequestHandleTcp(const char *data, const unsigned int &dataLength, ResponseHandle responseHandle, void *context) { cJSON *parsed = nullptr; std::string command = ""; parsed = cJSON_Parse(data); if (nullptr == parsed) { LogError("cJSON_Parse failed.\n"); responseHandle("Device run out of memory.", context); return; } cJSON *msgid = cJSON_GetObjectItem(parsed, "msgid"); if (cJSON_IsString(msgid)) { command = cJSON_GetStringValue(msgid); } LogInfo("command = %s\n", command.c_str()); RequestTcpHandle2(command, parsed, responseHandle, context); cJSON_Delete(parsed); } void SixFrameHandle::ExtractParamsFromUrl(const std::string &url, ParseUrlResultFunc resultHandle, std::shared_ptr &context) { size_t queryStartPos = url.find('?'); if (queryStartPos != std::string::npos && queryStartPos + 1 < url.length()) { std::string paramsStr = url.substr(queryStartPos + 1); std::istringstream iss(paramsStr); std::string token; while (getline(iss, token, '&')) { size_t equalSignPos = token.find('='); if (equalSignPos != std::string::npos) { std::string key = token.substr(0, equalSignPos); std::string value = token.substr(equalSignPos + 1); LogInfo("url get [%s] = %s\n", key.c_str(), value.c_str()); resultHandle(key, value, context); // paramsMap.insert({key, value}); } } } } void SixFrameHandle::RequestHandle2(const std::string command, const std::string &url, ResponseHandle responseHandle, void *context) { auto result = mResquesHandleFunc.find(command); if (result != mResquesHandleFunc.end()) { (*result).second(url, responseHandle, context); } else { LogError("Unknown command.\n"); DoNothing(url, responseHandle, context); } } void SixFrameHandle::DoNothing(const std::string &url, ResponseHandle responseHandle, void *context) { cJSON *result = MakeResponseResult(ResposeResult::FAILED); if (nullptr == result) { LogError("MakeResponseResult failed.\n"); responseHandle("Device run out of memory.", context); return; } ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void SixFrameHandle::RequestGetProductInfo(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetProductInfo.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetProductInfo(cJSON *result, const AppGetProductInfo ¶m) { cJSON *info = nullptr; cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject()); cJSON_AddStringToObject(info, "model", param.mModel.c_str()); cJSON_AddStringToObject(info, "company", param.mCompany.c_str()); cJSON_AddStringToObject(info, "soc", param.mSoc.c_str()); cJSON_AddStringToObject(info, "sp", param.mSp.c_str()); } void SixFrameHandle::RequestGetDeviceAttr(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetDeviceAttr.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetDeviceAttr(cJSON *result, const AppGetDeviceAttr ¶m) { 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(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetMediaInfo.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetMediaInfo(cJSON *result, const AppGetMeidaInfo ¶m) { cJSON *info = nullptr; cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject()); 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) { LogInfo("RequestGetDeviceAttr.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetSdCardInfo(cJSON *result, const AppGetSdCardInfo ¶m) { cJSON *info = nullptr; cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject()); cJSON_AddNumberToObject(info, "status", static_cast(param.mStatus)); cJSON_AddNumberToObject(info, "free", param.mFree); cJSON_AddNumberToObject(info, "total", param.mTotal); } void SixFrameHandle::RequestGetBatteryInfo(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetDeviceAttr.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetBatteryInfo(cJSON *result, const AppGetBatteryInfo ¶m) { cJSON *info = nullptr; cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject()); cJSON_AddNumberToObject(info, "charge", static_cast(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 &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("param" == key) { if ("rec" == value) { parseImpl->mData.mRec = SwitchStatus::ON; // means app want to get mRec value. } } }; std::shared_ptr parse = std::make_shared>(); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); ExtractParamsFromUrl(url, parseFunc, parse); return parseImpl->mData; } void SixFrameHandle::RequestGetParamValue(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetParamValue.\n"); // 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, paramDevice); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetParamValue(cJSON *result, const AppParamValue ¶m) { cJSON *info = cJSON_CreateArray(); if (nullptr == info) { LogError("cJSON_CreateArray failed.\n"); 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(param.mMicStatus)); } cJSON *rec = cJSON_CreateObject(); if (nullptr != rec) { cJSON_AddItemToArray(info, rec); cJSON_AddStringToObject(rec, "name", "rec"); cJSON_AddNumberToObject(rec, "value", static_cast(param.mRec)); } } void SixFrameHandle::RequestGetCapability(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetCapability.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetCapability(cJSON *result, const AppGetCapability ¶m) { cJSON *info = nullptr; cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject()); std::ostringstream value; value << static_cast(param.mGpsCapability); value << static_cast(param.mDeviceType); value << static_cast(param.mAlbum); value << static_cast(param.mAppLock); value << static_cast(param.mDeleteLock); value << static_cast(param.mDeviceMode); value << static_cast(param.mPlaybackType); value << static_cast(param.mPhotographCapability); value << static_cast(param.mWifiCapability); value << static_cast(param.mFileCopy); cJSON_AddStringToObject(info, "value", value.str().c_str()); } void SixFrameHandle::RequestGetLockVideoStatus(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetLockVideoStatus.\n"); 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetLockVideoStatus(cJSON *result, const LockVideoStatus ¶m) { cJSON *info = nullptr; cJSON_AddItemToObject(result, CJSON_INFO_STRING, info = cJSON_CreateObject()); cJSON_AddNumberToObject(info, "status", static_cast(param)); } void SixFrameHandle::RequestGetStorageInfo(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetStorageInfo.\n"); std::vector 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); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetStorageInfo(cJSON *result, const std::vector ¶m) { 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(storageInfo.mIndex)); cJSON_AddStringToObject(storage, "name", storageInfo.mName.c_str()); cJSON_AddNumberToObject(storage, "type", static_cast(storageInfo.mType)); cJSON_AddNumberToObject(storage, "free", storageInfo.mFree); cJSON_AddNumberToObject(storage, "total", storageInfo.mTotal); } } } AppGetFileInfo inline SixFrameHandle::RequestGetFileListParse(const std::string &url) { auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("folder" == key) { if ("loop" == value) { parseImpl->mData.mEvent = StorageFileEvent::LOOP; } if ("emr" == value) { parseImpl->mData.mEvent = StorageFileEvent::EMR; } if ("event" == value) { parseImpl->mData.mEvent = StorageFileEvent::EVENT; } if ("park" == value) { parseImpl->mData.mEvent = StorageFileEvent::PARK; } } if ("start" == key) { parseImpl->mData.mStartIndex = std::stoi(value); } if ("end" == key) { parseImpl->mData.mStopIndex = std::stoi(value); } }; std::shared_ptr parse = std::make_shared>(); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); ExtractParamsFromUrl(url, parseFunc, parse); return parseImpl->mData; } void SixFrameHandle::RequestGetFileList(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetFileList.\n"); std::vector files; AppGetFileInfo info = RequestGetFileListParse(url); mAppMonitor->GetStorageFileList(info, files); cJSON *result = MakeResponseResult(ResposeResult::SUCCESSFUL); if (nullptr == result) { LogError("MakeResponseResult failed.\n"); responseHandle("Device run out of memory.", context); return; } ResponseGetFileList(result, files, info); ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } void inline SixFrameHandle::ResponseGetFileList(cJSON *result, const std::vector ¶m, const AppGetFileInfo &fileInfo) { cJSON *info = cJSON_CreateArray(); cJSON *folder = cJSON_CreateObject(); cJSON *files = cJSON_CreateArray(); if (nullptr == info || nullptr == folder || nullptr == files) { LogError("cJSON_CreateArray failed.\n"); return; } cJSON_AddItemToObject(result, CJSON_INFO_STRING, info); cJSON_AddItemToArray(info, folder); for (const auto &fileList : param) { cJSON_AddStringToObject(folder, "folder", PrintfFileEvent(fileInfo)); cJSON_AddNumberToObject(folder, "count", param.size()); cJSON *file = nullptr; file = cJSON_CreateObject(); if (nullptr != file) { cJSON_AddItemToArray(files, file); cJSON_AddStringToObject(file, "name", fileList.mName.c_str()); cJSON_AddNumberToObject(file, "duration", fileList.mDuration); cJSON_AddNumberToObject(file, "size", fileList.mSize); cJSON_AddNumberToObject(file, "createtime", fileList.mCreateTime_s); cJSON_AddNumberToObject(file, "type", static_cast(fileList.mType)); } } cJSON_AddItemToObject(folder, CJSON_FILES_STRING, files); } AppSetDateTime inline SixFrameHandle::RequestSetDateTimeParse(const std::string &url) { auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("date" == key) { parseImpl->mData = value; } }; std::shared_ptr parse = std::make_shared>(); ExtractParamsFromUrl(url, parseFunc, parse); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if (14 != parseImpl->mData.length()) { LogError("date parse failed.\n"); return AppSetDateTime(0, 0, 0, 0, 0, 0); } 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); unsigned int hour = std::stoi(hourStr); unsigned int minute = std::stoi(minuteStr); unsigned int second = std::stoi(secondStr); return AppSetDateTime(year, month, day, hour, minute, second); } void SixFrameHandle::RequestSetDateTime(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetDeviceAttr.\n"); 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; } ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } int inline SixFrameHandle::RequestSetTimeZoneParse(const std::string &url) { auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("timezone" == key) { parseImpl->mData = value; } }; std::shared_ptr parse = std::make_shared>(); ExtractParamsFromUrl(url, parseFunc, parse); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if (2 <= parseImpl->mData.length()) { LogError("date parse failed.\n"); return 0; } int zone = std::stoi(parseImpl->mData); return zone; } void SixFrameHandle::RequestSetTimeZone(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestSetTimeZone.\n"); 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; } ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } AppSetParamValue inline SixFrameHandle::RequestSetParamValueParse(const std::string &url) { auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("switchcam" == key) { parseImpl->mData.mName = "switchcam"; parseImpl->mData.mValue = std::stoi(value); } if ("rec" == key) { parseImpl->mData.mName = "rec"; parseImpl->mData.mValue = std::stoi(value); } if ("mic" == key) { parseImpl->mData.mName = "mic"; parseImpl->mData.mValue = std::stoi(value); } }; AppSetParamValue value; std::shared_ptr parse = std::make_shared>(); ExtractParamsFromUrl(url, parseFunc, parse); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); return parseImpl->mData; } void SixFrameHandle::RequestSetParamValue(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestSetParamValue.\n"); 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; } 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 &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("param" == key) { if ("enter" == value) { parseImpl->mData = PlayBackEvent::START; } if ("exit" == value) { parseImpl->mData = PlayBackEvent::STOP; } } }; std::shared_ptr parse = std::make_shared>(); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); parseImpl->mData = PlayBackEvent::END; ExtractParamsFromUrl(url, parseFunc, parse); return parseImpl->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"); mAppMonitor->EnterRecorder(); 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::RequestUpload(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestUpload.\n"); 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; } ResponseJsonString(result, responseHandle, context); cJSON_Delete(result); } std::string inline SixFrameHandle::RequestGetThumbnailParse(const std::string &url) { auto parseFunc = [](const std::string &key, const std::string &value, std::shared_ptr &parse) { std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); if ("file" == key) { parseImpl->mData = value; } }; std::shared_ptr parse = std::make_shared>(); std::shared_ptr> parseImpl = std::dynamic_pointer_cast>(parse); ExtractParamsFromUrl(url, parseFunc, parse); return parseImpl->mData; } void SixFrameHandle::RequestGetThumbnail(const std::string &url, ResponseHandle responseHandle, void *context) { LogInfo("RequestGetThumbnail.\n"); const std::string file = RequestGetThumbnailParse(url); AppGetThumbnail respon(file); mAppMonitor->GetThumbnail(respon); // respon.mThumbnail = "./34a396526922a33e97906920dbfef2a5.jpg"; responseHandle(respon.mThumbnail.c_str(), context); } void SixFrameHandle::RequestTcpHandle2(const std::string command, const cJSON *const data, ResponseHandle responseHandle, void *context) { } std::shared_ptr SixFrameHandle::SetRecordingStatus(const RecordingStatus &status) { cJSON *resultCJSON = nullptr; CjsonAutoFree autoJson(resultCJSON = cJSON_CreateObject()); if (nullptr == resultCJSON) { LogError("cJSON_CreateObject failed.\n"); return std::make_shared(); } cJSON_AddStringToObject(resultCJSON, TCP_RESULT_MSGID, "rec"); cJSON *info = cJSON_CreateObject(); if (nullptr != info) { cJSON_AddNumberToObject(info, "value", static_cast(status)); cJSON_AddItemToObject(resultCJSON, CJSON_INFO_STRING, info); } AddTimestamp(resultCJSON); return MakePacket(resultCJSON); } std::shared_ptr SixFrameHandle::SetMicrophoneStatus(const MicrophoneStatus &status) { cJSON *resultCJSON = nullptr; CjsonAutoFree autoJson(resultCJSON = cJSON_CreateObject()); if (nullptr == resultCJSON) { LogError("cJSON_CreateObject failed.\n"); return std::make_shared(); } cJSON_AddStringToObject(resultCJSON, TCP_RESULT_MSGID, "mic"); cJSON *info = cJSON_CreateObject(); if (nullptr != info) { cJSON_AddNumberToObject(info, "value", static_cast(status)); cJSON_AddItemToObject(resultCJSON, CJSON_INFO_STRING, info); } AddTimestamp(resultCJSON); return MakePacket(resultCJSON); } std::shared_ptr SixFrameHandle::SetBatteryStatus(const BatteryStatus &status, const int &batteryCapacity) { cJSON *resultCJSON = nullptr; CjsonAutoFree autoJson(resultCJSON = cJSON_CreateObject()); if (nullptr == resultCJSON) { LogError("cJSON_CreateObject failed.\n"); return std::make_shared(); } cJSON_AddStringToObject(resultCJSON, TCP_RESULT_MSGID, "battery"); cJSON *info = cJSON_CreateObject(); if (nullptr != info) { cJSON_AddNumberToObject(info, "charge", static_cast(status)); cJSON_AddNumberToObject(info, "capacity", batteryCapacity); cJSON_AddItemToObject(resultCJSON, CJSON_INFO_STRING, info); } AddTimestamp(resultCJSON); return MakePacket(resultCJSON); } std::shared_ptr SixFrameHandle::SetSdCardStatus(const SdCardStatus &status) { cJSON *resultCJSON = nullptr; CjsonAutoFree autoJson(resultCJSON = cJSON_CreateObject()); if (nullptr == resultCJSON) { LogError("cJSON_CreateObject failed.\n"); return std::make_shared(); } cJSON_AddStringToObject(resultCJSON, TCP_RESULT_MSGID, "sd"); cJSON *info = cJSON_CreateObject(); if (nullptr != info) { cJSON_AddNumberToObject(info, "status", static_cast(status)); cJSON_AddItemToObject(resultCJSON, CJSON_INFO_STRING, info); } AddTimestamp(resultCJSON); return MakePacket(resultCJSON); } std::shared_ptr SixFrameHandle::DeletedFileMessage(const std::string &file, const StorageFileType &type) { cJSON *resultCJSON = nullptr; CjsonAutoFree autoJson(resultCJSON = cJSON_CreateObject()); if (nullptr == resultCJSON) { LogError("cJSON_CreateObject failed.\n"); return std::make_shared(); } cJSON_AddStringToObject(resultCJSON, TCP_RESULT_MSGID, "file_del"); cJSON *info = cJSON_CreateObject(); if (nullptr != info) { cJSON_AddStringToObject(info, "name", file.c_str()); cJSON_AddNumberToObject(info, "type", static_cast(type)); cJSON_AddItemToObject(resultCJSON, CJSON_INFO_STRING, info); } AddTimestamp(resultCJSON); return MakePacket(resultCJSON); } std::shared_ptr SixFrameHandle::CreatedFileMessage(const std::string &file, const StorageFileType &type) { cJSON *resultCJSON = nullptr; CjsonAutoFree autoJson(resultCJSON = cJSON_CreateObject()); if (nullptr == resultCJSON) { LogError("cJSON_CreateObject failed.\n"); return std::make_shared(); } cJSON_AddStringToObject(resultCJSON, TCP_RESULT_MSGID, "file_add"); cJSON *info = cJSON_CreateObject(); if (nullptr != info) { cJSON_AddStringToObject(info, "name", file.c_str()); cJSON_AddNumberToObject(info, "type", static_cast(type)); cJSON_AddItemToObject(resultCJSON, CJSON_INFO_STRING, info); } AddTimestamp(resultCJSON); return MakePacket(resultCJSON); } cJSON *SixFrameHandle::MakeResponseResult(const ResposeResult result, const bool requestSet) { 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(result)); if (false == requestSet) { goto END; } if (ResposeResult::SUCCESSFUL == result) { cJSON_AddStringToObject(resultCJSON, CJSON_INFO_STRING, "set success."); } else { cJSON_AddStringToObject(resultCJSON, CJSON_INFO_STRING, "set failed."); // TODO: what the failed string is? } END: return resultCJSON; } void SixFrameHandle::ResponseJsonString(cJSON *json, ResponseHandle responseHandle, void *context) { char *resultStr = nullptr; resultStr = cJSON_Print(json); if (nullptr != resultStr) { responseHandle(resultStr, context); free(resultStr); } else { LogError("MakeResponseResult failed.\n"); responseHandle("Device run out of memory.", context); } } const char *SixFrameHandle::PrintfFileEvent(const AppGetFileInfo &fileInfo) { switch (fileInfo.mEvent) { case StorageFileEvent::LOOP: { return "loop"; break; } default: { LogWarning("Unknown event.\n"); break; } } return "unknown event"; } void SixFrameHandle::AddTimestamp(cJSON *json) { time_t current_time; current_time = time(nullptr); if (current_time == -1) { LogError("Error getting the time\n"); return; } cJSON_AddNumberToObject(json, "time", current_time); } std::shared_ptr SixFrameHandle::MakePacket(const cJSON *json) { char *resultStr = nullptr; resultStr = cJSON_Print(json); if (nullptr != resultStr) { return std::make_shared(resultStr, strlen(resultStr)); } else { LogError("MakePacket failed.\n"); return std::make_shared(); } } void SixFrameHandle::SetAppMonitor(std::shared_ptr &monitor) { if (monitor) { mAppMonitor = monitor; } else { LogError("SetAppMonitor failed.\n"); } }