diff --git a/audiohandler/BUILD.gn b/audiohandler/BUILD.gn index 833ed5b9b4eebd41c052ddf0208fff473d23b90a..98287864231e7cb7e1e56710e8855bbee008228c 100644 --- a/audiohandler/BUILD.gn +++ b/audiohandler/BUILD.gn @@ -24,7 +24,6 @@ ohos_shared_library("distributed_audio_handler") { } stack_protector_ret = true include_dirs = [ - "//third_party/json/include", "${fwk_common_path}/utils/include", "${fwk_utils_path}/include", "${mediastandardfwk_path}/audiomanager/include", @@ -40,7 +39,10 @@ ohos_shared_library("distributed_audio_handler") { sources = [ "src/daudio_handler.cpp" ] - deps = [ "${services_path}/common:distributed_audio_utils" ] + deps = [ + "${services_path}/common:distributed_audio_utils", + "${third_party_path}/cJSON:cjson", + ] external_deps = [ "audio_framework:audio_capturer", diff --git a/audiohandler/include/daudio_handler.h b/audiohandler/include/daudio_handler.h index e93aab70dcbdc97b9479141be76e7301b8ce4439..fcad91183feda384064f2828a2a1d0bd60179839 100644 --- a/audiohandler/include/daudio_handler.h +++ b/audiohandler/include/daudio_handler.h @@ -17,6 +17,7 @@ #define OHOS_DAUDIO_HANDLER_H #include +#include "cJSON.h" #include "ihardware_handler.h" #include "single_instance.h" @@ -49,7 +50,7 @@ private: DAudioHandler(); ~DAudioHandler(); int32_t QueryAudioInfo(); - + void AddItemsToObject(DHItem &dhItem, cJSON *infoJson, const int32_t &dhId); private: AudioInfo spkInfos_; AudioInfo micInfos_; diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp index 3bf416bfaa8ee1dc474c702bab5576496237fef2..ddd959cdc294143b61efa3093845125516f28033 100644 --- a/audiohandler/src/daudio_handler.cpp +++ b/audiohandler/src/daudio_handler.cpp @@ -18,7 +18,6 @@ #include #include "audio_system_manager.h" -#include "nlohmann/json.hpp" #include "string_ex.h" #include "histreamer_query_tool.h" @@ -30,8 +29,6 @@ #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioHandler" -using json = nlohmann::json; - namespace OHOS { namespace DistributedHardware { IMPLEMENT_SINGLE_INSTANCE(DAudioHandler); @@ -52,6 +49,29 @@ int32_t DAudioHandler::Initialize() return QueryAudioInfo(); } +void DAudioHandler::AddItemsToObject(DHItem &dhItem, cJSON* infoJson, const int32_t &dhId) +{ + DHLOGD("Get dhId and then add other items into cjson object"); + int32_t deviceType = GetDevTypeByDHId(dhId); + if (deviceType == AUDIO_DEVICE_TYPE_MIC) { + dhItem.subtype = "mic"; + cJSON_AddItemToObject(infoJson, "SampleRates", + cJSON_CreateIntArray(reinterpret_cast(micInfos_.sampleRates.data()), micInfos_.sampleRates.size())); + cJSON_AddItemToObject(infoJson, "ChannelMasks", + cJSON_CreateIntArray(reinterpret_cast(micInfos_.channels.data()), micInfos_.channels.size())); + cJSON_AddItemToObject(infoJson, "Formats", + cJSON_CreateIntArray(reinterpret_cast(micInfos_.formats.data()), micInfos_.formats.size())); + } else if (deviceType == AUDIO_DEVICE_TYPE_SPEAKER) { + dhItem.subtype = "speaker"; + cJSON_AddItemToObject(infoJson, "SampleRates", + cJSON_CreateIntArray(reinterpret_cast(spkInfos_.sampleRates.data()), spkInfos_.sampleRates.size())); + cJSON_AddItemToObject(infoJson, "ChannelMasks", + cJSON_CreateIntArray(reinterpret_cast(spkInfos_.channels.data()), spkInfos_.channels.size())); + cJSON_AddItemToObject(infoJson, "Formats", + cJSON_CreateIntArray(reinterpret_cast(spkInfos_.formats.data()), spkInfos_.formats.size())); + } +} + std::vector DAudioHandler::Query() { DHLOGI("Query distributed hardware information."); @@ -66,33 +86,32 @@ std::vector DAudioHandler::Query() for (auto dev : audioDevices) { auto dhId = audioSrv->GetPinValueFromType(dev->deviceType_, dev->deviceRole_); - json infoJson; - DHItem dhItem; - int32_t deviceType = GetDevTypeByDHId(dhId); - if (deviceType == AUDIO_DEVICE_TYPE_MIC) { - dhItem.subtype = "mic"; - infoJson["SampleRates"] = micInfos_.sampleRates; - infoJson["ChannelMasks"] = micInfos_.channels; - infoJson["Formats"] = micInfos_.formats; - } else if (deviceType == AUDIO_DEVICE_TYPE_SPEAKER) { - dhItem.subtype = "speaker"; - infoJson["SampleRates"] = spkInfos_.sampleRates; - infoJson["ChannelMasks"] = spkInfos_.channels; - infoJson["Formats"] = spkInfos_.formats; + cJSON* infoJson = cJSON_CreateObject(); + if (infoJson == nullptr) { + DHLOGE("Failed to create cJSON object."); + return dhItemVec; } - infoJson["INTERRUPT_GROUP_ID"] = dev->interruptGroupId_; - infoJson["VOLUME_GROUP_ID"] = dev->volumeGroupId_; - + DHItem dhItem; + AddItemsToObject(dhItem, infoJson, dhId); + cJSON_AddNumberToObject(infoJson, "INTERRUPT_GROUP_ID", dev->interruptGroupId_); + cJSON_AddNumberToObject(infoJson, "VOLUME_GROUP_ID", dev->volumeGroupId_); dhItem.dhId = std::to_string(dhId); - dhItem.attrs = infoJson.dump(); + char *jsonInfo = cJSON_Print(infoJson); + if (jsonInfo == NULL) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(infoJson); + return dhItemVec; + } + dhItem.attrs = jsonInfo; dhItemVec.push_back(dhItem); - DHLOGD("Query result: dhId: %d, subtype: %s, attrs: %s.", dhId, dhItem.subtype.c_str(), - infoJson.dump().c_str()); + DHLOGD("Query result: dhId: %d, subtype: %s, attrs: %s.", dhId, dhItem.subtype.c_str(), jsonInfo); if (dhId == DEFAULT_RENDER_ID) { dhItem.dhId = std::to_string(LOW_LATENCY_RENDER_ID); dhItemVec.push_back(dhItem); - DHLOGD("Query result: dhId: %d, attrs: %s.", LOW_LATENCY_RENDER_ID, infoJson.dump().c_str()); + DHLOGD("Query result: dhId: %d, attrs: %s.", LOW_LATENCY_RENDER_ID, jsonInfo); } + cJSON_Delete(infoJson); + cJSON_free(jsonInfo); } ablityForDumpVec_ = dhItemVec; return dhItemVec; diff --git a/audiohandler/test/unittest/BUILD.gn b/audiohandler/test/unittest/BUILD.gn index 2c79183180b2af39a7fbd07fce6312132ae0fba9..e2b6b28d137094d9119c8837543a88fa15670b5f 100644 --- a/audiohandler/test/unittest/BUILD.gn +++ b/audiohandler/test/unittest/BUILD.gn @@ -20,7 +20,6 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ - "//third_party/json/include", "${fwk_common_path}/utils/include", "${mediastandard_path}/interfaces/inner_api/native", "${mediastandard_path}/services/utils/include", @@ -47,6 +46,7 @@ ohos_unittest("AudioHandlerTest") { deps = [ "${distributedaudio_path}/audiohandler:distributed_audio_handler", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gtest_main", ] diff --git a/bundle.json b/bundle.json index 942a75ba5576df7a8f944f4f8118c4c5c715c191..0e9ab08d2c29de11141516fc1dc23e245858dc19 100755 --- a/bundle.json +++ b/bundle.json @@ -49,7 +49,6 @@ "samgr" ], "third_party": [ - "json", "cJSON" ] }, diff --git a/common/dfx_utils/test/unittest/BUILD.gn b/common/dfx_utils/test/unittest/BUILD.gn index 358418166448fc1c258fd0504e9a7659ec427735..bc72e023f0dd6e57fd5a05bcdd0ee2f0c733e42a 100644 --- a/common/dfx_utils/test/unittest/BUILD.gn +++ b/common/dfx_utils/test/unittest/BUILD.gn @@ -45,7 +45,6 @@ config("module_private_config") { "${services_path}/common/audiodata/include", "${services_path}/common/audioeventcallback", "${services_path}/audiomanager/managersource/include", - "//third_party/json/include", "${fwk_common_path}/utils/include", "${mediastandardfwk_path}/audiocapturer/include", "${mediastandardfwk_path}/audiocommon/include", diff --git a/common/include/daudio_log.h b/common/include/daudio_log.h index 25f16cc13507ebe1910a29cfac906947b689ecd7..f74e6865e40b1955a397a5e8875101e916935806 100644 --- a/common/include/daudio_log.h +++ b/common/include/daudio_log.h @@ -15,6 +15,7 @@ #ifndef OHOS_DAUDIO_LOG_H #define OHOS_DAUDIO_LOG_H +#include "cJSON.h" namespace OHOS { namespace DistributedHardware { @@ -47,6 +48,15 @@ void DHLog(DHLogLevel logLevel, const char *fmt, ...); } \ } while (0) +#define CHECK_NULL_AND_FREE_VOID(ptr, root, ...) \ + do { \ + if ((ptr) == nullptr) { \ + DHLOGE("Address pointer is null"); \ + cJSON_Delete(root); \ + return; \ + } \ + } while (0) + #define CHECK_NULL_RETURN(ptr, ret) \ do { \ if ((ptr) == nullptr) { \ @@ -55,6 +65,15 @@ void DHLog(DHLogLevel logLevel, const char *fmt, ...); } \ } while (0) +#define CHECK_NULL_FREE_RETURN(ptr, ret, root, ...) \ + do { \ + if ((ptr) == nullptr) { \ + DHLOGE("Address pointer is null"); \ + cJSON_Delete(root); \ + return (ret); \ + } \ + } while (0) + #define CHECK_AND_RETURN_RET_LOG(cond, ret, fmt, ...) \ do { \ if ((cond)) { \ @@ -63,6 +82,24 @@ void DHLog(DHLogLevel logLevel, const char *fmt, ...); } \ } while (0) +#define CHECK_AND_FREE_RETURN_RET_LOG(cond, ret, root, fmt, ...) \ + do { \ + if ((cond)) { \ + DHLOGE(fmt, ##__VA_ARGS__); \ + cJSON_Delete(root); \ + return (ret); \ + } \ + } while (0) + +#define CHECK_AND_FREECHAR_RETURN_RET_LOG(cond, ret, data, fmt, ...) \ + do { \ + if ((cond)) { \ + DHLOGE(fmt, ##__VA_ARGS__); \ + cJSON_free(data); \ + return (ret); \ + } \ + } while (0) + #define CHECK_AND_RETURN_LOG(cond, fmt, ...) \ do { \ if ((cond)) { \ @@ -71,6 +108,15 @@ void DHLog(DHLogLevel logLevel, const char *fmt, ...); } \ } while (0) +#define CHECK_AND_FREE_RETURN_LOG(cond, root, fmt, ...) \ + do { \ + if ((cond)) { \ + DHLOGE(fmt, ##__VA_ARGS__); \ + cJSON_Delete(root); \ + return; \ + } \ + } while (0) + #define CHECK_AND_LOG(cond, fmt, ...) \ do { \ if ((cond)) { \ diff --git a/common/include/daudio_util.h b/common/include/daudio_util.h index e7c3a577ef811d8337ea91fbd3d06fc701e139bb..63dad1b1d503e1fc49d2b34f8c4119c3aafcf274 100644 --- a/common/include/daudio_util.h +++ b/common/include/daudio_util.h @@ -19,11 +19,8 @@ #include #include #include -#include "nlohmann/json.hpp" #include "cJSON.h" -using json = nlohmann::json; - #define AUDIO_MS_PER_SECOND 1000 #define AUDIO_US_PER_SECOND 1000000 #define AUDIO_NS_PER_SECOND ((int64_t)1000000000) @@ -37,11 +34,10 @@ int64_t GetNowTimeUs(); int32_t GetAudioParamStr(const std::string ¶ms, const std::string &key, std::string &value); int32_t GetAudioParamBool(const std::string ¶ms, const std::string &key, bool &value); int32_t GetAudioParamInt(const std::string ¶ms, const std::string &key, int32_t &value); -bool JsonParamCheck(const json &jsonObj, const std::initializer_list &key); bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list &keys); -bool IsString(const json &jsonObj, const std::string &key); -bool IsInt32(const json &jsonObj, const std::string &key); -bool IsAudioParam(const json &jsonObj, const std::string &key); +bool IsString(const cJSON *jsonObj, const std::string &key); +bool IsInt32(const cJSON *jsonObj, const std::string &key); +bool IsAudioParam(const cJSON *jsonObj, const std::string &key); int32_t CalculateSampleNum(uint32_t sampleRate, uint32_t timems); int64_t GetCurNano(); int32_t AbsoluteSleep(int64_t nanoTime); diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp index 78f50ed52b4a19894b415bacfe537906a5297912..8f3a6d0e720396e4aaf161ace19438d1941427ee 100644 --- a/common/src/daudio_util.cpp +++ b/common/src/daudio_util.cpp @@ -36,7 +36,7 @@ namespace OHOS { namespace DistributedHardware { -using JsonTypeCheckFunc = bool (*)(const json &jsonObj, const std::string &key); +using JsonTypeCheckFunc = bool (*)(const cJSON *jsonObj, const std::string &key); constexpr int32_t WORD_WIDTH_8 = 8; constexpr int32_t WORD_WIDTH_4 = 4; constexpr size_t INT32_SHORT_ID_LENGTH = 20; @@ -261,35 +261,25 @@ int32_t GetAudioParamInt(const std::string ¶ms, const std::string &key, int3 return DH_SUCCESS; } -bool JsonParamCheck(const json &jsonObj, const std::initializer_list &keys) +bool IsString(const cJSON *jsonObj, const std::string &key) { - if (jsonObj.is_discarded()) { - DHLOGE("Json parameter is invalid."); + if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) { + DHLOGE("JSON parameter is invalid."); + return false; + } + cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(jsonObj, key.c_str()); + if (paramValue == nullptr) { + DHLOGE("paramValue is null"); return false; } - for (auto it = keys.begin(); it != keys.end(); it++) { - if (!jsonObj.contains(*it)) { - DHLOGE("Json parameter not contain param(%s).", (*it).c_str()); - return false; - } - - auto iter = typeCheckMap.find(*it); - if (iter == typeCheckMap.end()) { - DHLOGE("Check is not supported yet, key %s.", (*it).c_str()); - return false; - } - JsonTypeCheckFunc &func = iter->second; - bool res = (*func)(jsonObj, *it); - if (!res) { - DHLOGE("The key %s value format in json is illegal.", (*it).c_str()); - return false; - } + if (cJSON_IsString(paramValue)) { + return true; } - return true; + return false; } -static bool IsString(const cJSON *jsonObj, const std::string &key) +bool IsInt32(const cJSON *jsonObj, const std::string &key) { if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) { DHLOGE("JSON parameter is invalid."); @@ -301,12 +291,31 @@ static bool IsString(const cJSON *jsonObj, const std::string &key) return false; } - if (cJSON_IsString(paramValue)) { - return true; + if (cJSON_IsNumber(paramValue)) { + int value = paramValue->valueint; + if (INT32_MIN <= value && value <= INT32_MAX) { + return true; + } } return false; } +bool IsAudioParam(const cJSON *jsonObj, const std::string &key) +{ + if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) { + DHLOGE("JSON parameter is invalid."); + return false; + } + cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(jsonObj, key.c_str()); + if (paramValue == nullptr || !cJSON_IsObject(paramValue)) { + DHLOGE("paramValue is null or is not object"); + return false; + } + + return CJsonParamCheck(paramValue, + { KEY_SAMPLING_RATE, KEY_CHANNELS, KEY_FORMAT, KEY_SOURCE_TYPE, KEY_CONTENT_TYPE, KEY_STREAM_USAGE }); +} + bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list &keys) { if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) { @@ -320,7 +329,13 @@ bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_listsecond; + bool res = (*func)(jsonObj, *it); if (!res) { DHLOGE("The key %s value format in JSON is illegal.", (*it).c_str()); return false; @@ -329,22 +344,6 @@ bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list #include #include +#include "cJSON.h" #include "event_handler.h" -#include "nlohmann/json.hpp" #include "daudio_sink_dev_ctrl_mgr.h" #include "dmic_client.h" @@ -34,8 +34,6 @@ #include "i_av_receiver_engine_callback.h" #include "idaudio_sink_ipc_callback.h" -using json = nlohmann::json; - namespace OHOS { namespace DistributedHardware { enum class ChannelState { @@ -74,11 +72,13 @@ private: int32_t TaskDisableDevice(const std::string &args); void NotifySourceDev(const AudioEventType type, const std::string dhId, const int32_t result); - int32_t from_json(const json &j, AudioParam &audioParam); + int32_t from_json(const cJSON *j, AudioParam &audioParam); int32_t HandleEngineMessage(uint32_t type, std::string content, std::string devId); int32_t SendAudioEventToRemote(const AudioEvent &event); void PullUpPage(); + int32_t GetParamValue(const cJSON *j, const char* key, int32_t &value); + int32_t GetCJsonObjectItems(const cJSON *j, AudioParam &audioParam); int32_t ParseDhidFromEvent(std::string args); int32_t ConvertString2Int(std::string val); diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 5a62185885ee6b9aeac7b8321b4705c1ff5f1d5f..b1cc12affad0eb2cb59a748fc97906cd05aa7bb8 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -18,8 +18,6 @@ #include -#include "cJSON.h" - #include "daudio_constants.h" #include "daudio_errorcode.h" #include "daudio_log.h" @@ -122,27 +120,35 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { + cJSON *jParam = cJSON_Parse(args.c_str()); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + if (!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { + cJSON_Delete(jParam); + DHLOGE("Not found the keys."); return ERR_DH_AUDIO_FAILED; } - int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID])); - CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, + int32_t dhId = ConvertString2Int(std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); + CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam, "%s", "Parse dhId error."); std::shared_ptr speakerClient = nullptr; { std::lock_guard devLck(spkClientMutex_); speakerClient = spkClientMap_[dhId]; } + cJSON *audioParamJson = cJSON_GetObjectItem(jParam, KEY_AUDIO_PARAM); AudioParam audioParam; - int32_t ret = from_json(jParam[KEY_AUDIO_PARAM], audioParam); - CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, - "Get audio param from json failed, error code %d.", ret); - CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR); + int32_t ret = from_json(audioParamJson, audioParam); + if (ret != DH_SUCCESS) { + DHLOGE("Get audio param from cjson failed, error code %d.", ret); + cJSON_Delete(jParam); + return ret; + } + CHECK_NULL_FREE_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR, jParam); ret = speakerClient->SetUp(audioParam); - CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ret, jParam, "Setup speaker failed, ret: %d.", ret); isSpkInUse_.store(true); + cJSON_Delete(jParam); return ret; } @@ -221,32 +227,42 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { + cJSON *jParam = cJSON_Parse(args.c_str()); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + if (!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { + DHLOGE("Not found the keys."); + cJSON_Delete(jParam); return ERR_DH_AUDIO_FAILED; } AudioParam audioParam; - int32_t ret = from_json(jParam[KEY_AUDIO_PARAM], audioParam); - CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, - "Get audio param from json failed, error code %d.", ret); - micDhId_ = std::string(jParam[KEY_DH_ID]); - int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID])); - CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, + cJSON *audioParamJson = cJSON_GetObjectItem(jParam, KEY_AUDIO_PARAM); + int32_t ret = from_json(audioParamJson, audioParam); + if (ret != DH_SUCCESS) { + DHLOGE("Get audio param from cjson failed, error code %d.", ret); + cJSON_Delete(jParam); + return ret; + } + CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ret, jParam, + "Get audio param from cjson failed, error code %d.", ret); + int32_t dhId = ParseDhidFromEvent(args); + CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam, "%s", "Parse dhId error."); + micDhId_ = std::to_string(dhId); std::shared_ptr micClient = nullptr; { std::lock_guard devLck(micClientMutex_); micClient = micClientMap_[dhId]; } - CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR); + CHECK_NULL_FREE_RETURN(micClient, ERR_DH_AUDIO_NULLPTR, jParam); ret = micClient->SetUp(audioParam); - CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, + CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, jParam, "Set up mic failed, ret: %d.", ret); ret = micClient->StartCapture(); - CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, + CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, jParam, "Start capture failed, ret: %d.", ret); PullUpPage(); isMicInUse_.store(true); + cJSON_Delete(jParam); return ret; } @@ -438,29 +454,40 @@ void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string { std::random_device rd; const uint32_t randomTaskCode = rd(); - json jEvent; - jEvent[KEY_DH_ID] = dhId; - jEvent[KEY_RESULT] = result; - jEvent[KEY_EVENT_TYPE] = type; - jEvent[KEY_RANDOM_TASK_CODE] = std::to_string(randomTaskCode); + cJSON *jEvent = cJSON_CreateObject(); + CHECK_NULL_VOID(jEvent); + cJSON_AddStringToObject(jEvent, KEY_DH_ID, dhId.c_str()); + cJSON_AddNumberToObject(jEvent, KEY_RESULT, result); + cJSON_AddNumberToObject(jEvent, KEY_EVENT_TYPE, static_cast(type)); + cJSON_AddStringToObject(jEvent, KEY_RANDOM_TASK_CODE, std::to_string(randomTaskCode).c_str()); DHLOGD("Notify source dev, new engine, random task code:%s", std::to_string(randomTaskCode).c_str()); if (type == NOTIFY_OPEN_CTRL_RESULT || type == NOTIFY_CLOSE_CTRL_RESULT) { DHLOGE("In new engine mode, ctrl is not allowed."); + cJSON_Delete(jEvent); return; } int32_t dhIdInt = ConvertString2Int(dhId); if (dhIdInt == -1) { DHLOGE("Parse dhId error."); + cJSON_Delete(jEvent); return; } + char *data = cJSON_PrintUnformatted(jEvent); + if (data == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jEvent); + return; + } + std::string message(data); + std::shared_ptr speakerClient = nullptr; { std::lock_guard devLck(spkClientMutex_); speakerClient = spkClientMap_[dhIdInt]; } if (speakerClient != nullptr) { - speakerClient->SendMessage(static_cast(type), jEvent.dump(), devId_); + speakerClient->SendMessage(static_cast(type), message, devId_); } std::shared_ptr micClient = nullptr; { @@ -468,25 +495,57 @@ void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string micClient = micClientMap_[dhIdInt]; } if (micClient != nullptr) { - micClient->SendMessage(static_cast(type), jEvent.dump(), devId_); + micClient->SendMessage(static_cast(type), message, devId_); } + cJSON_Delete(jEvent); + cJSON_free(data); } -int32_t DAudioSinkDev::from_json(const json &j, AudioParam &audioParam) +int32_t DAudioSinkDev::GetParamValue(const cJSON *j, const char* key, int32_t &value) { - if (!JsonParamCheck(j, { KEY_SAMPLING_RATE, KEY_CHANNELS, KEY_FORMAT, + cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(j, key); + if (paramValue == nullptr || !cJSON_IsNumber(paramValue)) { + return ERR_DH_AUDIO_FAILED; + } + value = paramValue->valueint; + return DH_SUCCESS; +} + +int32_t DAudioSinkDev::GetCJsonObjectItems(const cJSON *j, AudioParam &audioParam) +{ + int32_t ret = 0; + ret = GetParamValue(j, KEY_SAMPLING_RATE, reinterpret_cast(audioParam.comParam.sampleRate)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_CHANNELS, reinterpret_cast(audioParam.comParam.channelMask)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_FORMAT, reinterpret_cast(audioParam.comParam.bitFormat)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_FRAMESIZE, reinterpret_cast(audioParam.comParam.frameSize)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_SOURCE_TYPE, reinterpret_cast(audioParam.captureOpts.sourceType)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_CONTENT_TYPE, reinterpret_cast(audioParam.renderOpts.contentType)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_STREAM_USAGE, reinterpret_cast(audioParam.renderOpts.streamUsage)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_RENDER_FLAGS, reinterpret_cast(audioParam.renderOpts.renderFlags)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + ret = GetParamValue(j, KEY_CAPTURE_FLAGS, reinterpret_cast(audioParam.captureOpts.capturerFlags)); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "%s", "Get param value error."); + return ret; +} + +int32_t DAudioSinkDev::from_json(const cJSON *j, AudioParam &audioParam) +{ + if (!CJsonParamCheck(j, { KEY_SAMPLING_RATE, KEY_CHANNELS, KEY_FORMAT, KEY_SOURCE_TYPE, KEY_CONTENT_TYPE, KEY_STREAM_USAGE })) { + DHLOGE("Not found the keys of dhId"); + return ERR_DH_AUDIO_FAILED; + } + if (GetCJsonObjectItems(j, audioParam) != DH_SUCCESS) { + DHLOGE("Get Cjson Object Items failed."); return ERR_DH_AUDIO_FAILED; } - j.at(KEY_SAMPLING_RATE).get_to(audioParam.comParam.sampleRate); - j.at(KEY_CHANNELS).get_to(audioParam.comParam.channelMask); - j.at(KEY_FORMAT).get_to(audioParam.comParam.bitFormat); - j.at(KEY_FRAMESIZE).get_to(audioParam.comParam.frameSize); - j.at(KEY_SOURCE_TYPE).get_to(audioParam.captureOpts.sourceType); - j.at(KEY_CONTENT_TYPE).get_to(audioParam.renderOpts.contentType); - j.at(KEY_STREAM_USAGE).get_to(audioParam.renderOpts.streamUsage); - j.at(KEY_RENDER_FLAGS).get_to(audioParam.renderOpts.renderFlags); - j.at(KEY_CAPTURE_FLAGS).get_to(audioParam.captureOpts.capturerFlags); return DH_SUCCESS; } @@ -571,13 +630,10 @@ void DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker(const AppExecFwk::InnerE auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - json jParam = json::parse(eventParam, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { - DHLOGE("Json param check failed."); - return; - } + int32_t dhId = sinkDevObj->ParseDhidFromEvent(eventParam); + CHECK_AND_RETURN_LOG(dhId == -1, "%s", "Parse dhId error."); int32_t ret = sinkDevObj->TaskOpenDSpeaker(eventParam); - sinkDevObj->NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, jParam[KEY_DH_ID], ret); + sinkDevObj->NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, std::to_string(dhId), ret); DHLOGI("Open speaker device task end, notify source ret %d.", ret); CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%s", "Open speaker failed."); } @@ -634,15 +690,19 @@ void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - json jParam = json::parse(eventParam, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { + cJSON *jParam = cJSON_Parse(eventParam.c_str()); + CHECK_NULL_VOID(jParam); + if (!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { DHLOGE("Json param check failed."); + cJSON_Delete(jParam); return; } int32_t ret = sinkDevObj->TaskOpenDMic(eventParam); - sinkDevObj->NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, jParam[KEY_DH_ID], ret); + sinkDevObj->NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, + std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring), ret); DHLOGI("Open mic device task end, notify source ret %d.", ret); - CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%s", "Open mic failed."); + CHECK_AND_FREE_RETURN_LOG(ret != DH_SUCCESS, jParam, "%s", "Open mic failed."); + cJSON_Delete(jParam); } void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event) diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp index 5d172c50f6cbad9df8041ee1c2bb847678530480..b180b0f2e6ed57b833b070140a9354c7b242d288 100644 --- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp @@ -141,10 +141,10 @@ int32_t DAudioSinkManager::HandleDAudioNotify(const std::string &devId, const st } // now ctrl channel is also goto here, please sure here not crash. - json jParam = json::parse(eventContent, nullptr, false); - if (JsonParamCheck(jParam, { KEY_RANDOM_TASK_CODE })) { + cJSON *jParam = cJSON_Parse(eventContent.c_str()); + if (CJsonParamCheck(jParam, { KEY_RANDOM_TASK_CODE })) { DHLOGD("Receive audio notify from source, random task code: %s", - ((std::string)jParam[KEY_RANDOM_TASK_CODE]).c_str()); + cJSON_GetObjectItemCaseSensitive(jParam, KEY_RANDOM_TASK_CODE)->valuestring); } bool isDevExisted = false; { @@ -154,9 +154,11 @@ int32_t DAudioSinkManager::HandleDAudioNotify(const std::string &devId, const st if (!isDevExisted) { DHLOGE("Device is not exist, devId: %s, dhId: %s.", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str()); + cJSON_Delete(jParam); return ERR_DH_AUDIO_FAILED; } NotifyEvent(devId, eventType, eventContent); + cJSON_Delete(jParam); return DH_SUCCESS; } diff --git a/services/audiomanager/managersource/include/daudio_source_dev.h b/services/audiomanager/managersource/include/daudio_source_dev.h index 79e24d1b141f6c3295ccad02e5fa78fa668ed59e..87e56b742b918cf779082b54eea88eac19a11307 100644 --- a/services/audiomanager/managersource/include/daudio_source_dev.h +++ b/services/audiomanager/managersource/include/daudio_source_dev.h @@ -19,7 +19,7 @@ #include #include #include -#include "nlohmann/json.hpp" +#include "cJSON.h" #include "event_handler.h" @@ -35,8 +35,6 @@ #include "idaudio_ipc_callback.h" #include "idaudio_hdi_callback.h" -using json = nlohmann::json; - namespace OHOS { namespace DistributedHardware { class DAudioSourceDev : public IAudioEventCallback, public std::enable_shared_from_this { @@ -59,6 +57,7 @@ private: int32_t EnableDMic(const int32_t dhId, const std::string &attrs); int32_t DisableDSpeaker(const int32_t dhId); int32_t DisableDMic(const int32_t dhId); + int32_t DisableDAudioInner(const std::string &dhId); int32_t TaskEnableDAudio(const std::string &args); int32_t TaskDisableDAudio(const std::string &args); @@ -103,10 +102,10 @@ private: int32_t HandleMicMmapStart(const AudioEvent &event); int32_t HandleMicMmapStop(const AudioEvent &event); - int32_t NotifySinkDev(const AudioEventType type, const json Param, const std::string dhId); + int32_t NotifySinkDev(const AudioEventType type, const cJSON *Param, const std::string dhId); int32_t NotifyHDF(const AudioEventType type, const std::string result, const int32_t dhId); AudioEventType getEventTypeFromArgs(const std::string &args); - void to_json(json &j, const AudioParam ¶m); + void to_json(cJSON *j, const AudioParam ¶m); int32_t SendAudioEventToRemote(const AudioEvent &event); int32_t CloseSpkNew(const std::string &args); int32_t CloseMicNew(const std::string &args); diff --git a/services/audiomanager/managersource/include/dmic_dev.h b/services/audiomanager/managersource/include/dmic_dev.h index 68d9868102e6ba903065cdb6a55cdf75b203a90c..41786ab55e681c342af13195580e2d8cea3a379f 100644 --- a/services/audiomanager/managersource/include/dmic_dev.h +++ b/services/audiomanager/managersource/include/dmic_dev.h @@ -19,7 +19,7 @@ #include #include #include -#include "nlohmann/json.hpp" +#include "cJSON.h" #include "audio_param.h" #include "audio_status.h" @@ -33,8 +33,6 @@ #include "iaudio_event_callback.h" #include "idaudio_hdi_callback.h" -using json = nlohmann::json; - namespace OHOS { namespace DistributedHardware { class DMicDev : public DAudioIoDev, diff --git a/services/audiomanager/managersource/include/dspeaker_dev.h b/services/audiomanager/managersource/include/dspeaker_dev.h index bbe113543a6021983183c28083553fb7a75da60c..c6c836a6bd9071b84b17edd6d8d271c94e4cdd43 100644 --- a/services/audiomanager/managersource/include/dspeaker_dev.h +++ b/services/audiomanager/managersource/include/dspeaker_dev.h @@ -19,7 +19,7 @@ #include #include #include -#include "nlohmann/json.hpp" +#include "cJSON.h" #include "audio_param.h" #include "ashmem.h" @@ -32,8 +32,6 @@ #include "iaudio_datatrans_callback.h" #include "idaudio_hdi_callback.h" -using json = nlohmann::json; - namespace OHOS { namespace DistributedHardware { class DSpeakerDev : public DAudioIoDev, diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index ceb0c6b2b96fbc6bfe79cd1f736a0dbc50ce775b..e3021c43288d0022e05b87757080901998e1b284 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -113,14 +113,54 @@ int32_t DAudioSourceDev::EnableDAudio(const std::string &dhId, const std::string isRpcOpen_.store(true); CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DEV_ID, devId_ }, { KEY_DH_ID, dhId }, { KEY_ATTRS, attrs } }; - auto eventParam = std::make_shared(jParam); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DEV_ID, devId_.c_str()); + cJSON_AddStringToObject(jParam, KEY_DH_ID, dhId.c_str()); + cJSON_AddStringToObject(jParam, KEY_ATTRS, attrs.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + if (jsonString == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + auto eventParam = std::make_shared(jsonString); auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_DAUDIO_ENABLE, eventParam, 0); if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { DHLOGE("Send event failed."); + cJSON_Delete(jParam); + cJSON_free(jsonString); return ERR_DH_AUDIO_FAILED; } DHLOGI("Enable audio task generate successfully."); + cJSON_Delete(jParam); + cJSON_free(jsonString); + return DH_SUCCESS; +} + +int32_t DAudioSourceDev::DisableDAudioInner(const std::string &dhId) +{ + CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DEV_ID, devId_.c_str()); + cJSON_AddStringToObject(jParam, KEY_DH_ID, dhId.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + if (jsonString == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + auto eventParam = std::make_shared(jsonString); + auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_DAUDIO_DISABLE, eventParam, 0); + if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { + DHLOGE("Send event failed."); + cJSON_Delete(jParam); + cJSON_free(jsonString); + return ERR_DH_AUDIO_FAILED; + } + cJSON_Delete(jParam); + cJSON_free(jsonString); return DH_SUCCESS; } @@ -128,15 +168,19 @@ int32_t DAudioSourceDev::DisableDAudio(const std::string &dhId) { DHLOGI("Disable audio device, dhId: %s.", dhId.c_str()); isRpcOpen_.store(false); - CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); - json jParamClose = { { KEY_DH_ID, dhId } }; - AudioEvent event(AudioEventType::EVENT_UNKNOWN, jParamClose.dump()); - int32_t dhIdNum = ConvertString2Int(dhId); - if (dhIdNum == -1) { - DHLOGE("Parse dhId error."); - return ERR_DH_AUDIO_NOT_SUPPORT; + cJSON *jParamClose = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParamClose, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParamClose, KEY_DH_ID, dhId.c_str()); + char *data = cJSON_PrintUnformatted(jParamClose); + if (data == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParamClose); + return ERR_DH_AUDIO_NULLPTR; } + AudioEvent event(AudioEventType::EVENT_UNKNOWN, std::string(data)); + int32_t dhIdNum = ConvertString2Int(dhId); + CHECK_AND_FREECHAR_RETURN_RET_LOG(dhIdNum == -1, ERR_DH_AUDIO_NOT_SUPPORT, data, "%s", "Parse dhId error."); switch (GetDevTypeByDHId(dhIdNum)) { case AUDIO_DEVICE_TYPE_SPEAKER: event.type = CLOSE_SPEAKER; @@ -147,16 +191,17 @@ int32_t DAudioSourceDev::DisableDAudio(const std::string &dhId) HandleCloseDMic(event); break; default: + cJSON_Delete(jParamClose); + cJSON_free(data); DHLOGE("Unknown audio device. dhId: %d.", dhIdNum); return ERR_DH_AUDIO_NOT_SUPPORT; } - - json jParam = { { KEY_DEV_ID, devId_ }, { KEY_DH_ID, dhId } }; - auto eventParam = std::make_shared(jParam); - auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_DAUDIO_DISABLE, eventParam, 0); - if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { - DHLOGE("Send event failed."); - return ERR_DH_AUDIO_FAILED; + cJSON_Delete(jParamClose); + cJSON_free(data); + int32_t ret = DisableDAudioInner(dhId); + if (ret != DH_SUCCESS) { + DHLOGE("Failed to disable audio device, result is: %d.", ret); + return ret; } DHLOGI("Disable audio task generate successfully."); return DH_SUCCESS; @@ -165,13 +210,24 @@ int32_t DAudioSourceDev::DisableDAudio(const std::string &dhId) int32_t DAudioSourceDev::RestoreThreadStatus() { CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); - json jParam; - auto eventParam = std::make_shared(jParam); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + char *jsonString = cJSON_PrintUnformatted(jParam); + if (jsonString == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + auto eventParam = std::make_shared(jsonString); auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_SET_THREAD_STATUS, eventParam, 0); if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { DHLOGE("Send event failed."); + cJSON_Delete(jParam); + cJSON_free(jsonString); return ERR_DH_AUDIO_FAILED; } + cJSON_Delete(jParam); + cJSON_free(jsonString); return DH_SUCCESS; } @@ -323,20 +379,25 @@ int32_t DAudioSourceDev::HandleNotifyRPC(const AudioEvent &event) if (event.content.length() > DAUDIO_MAX_JSON_LEN || event.content.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - json jParam = json::parse(event.content, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_RESULT })) { + cJSON *jParam = cJSON_Parse(event.content.c_str()); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + if (!CJsonParamCheck(jParam, { KEY_RESULT })) { + DHLOGE("Not found the keys of result."); + cJSON_Delete(jParam); return ERR_DH_AUDIO_FAILED; } - rpcResult_ = jParam[KEY_RESULT]; + rpcResult_ = cJSON_GetObjectItem(jParam, KEY_RESULT)->valueint; DHLOGD("Notify RPC event: %d, result: %d.", event.type, rpcResult_); std::map::iterator iter = eventNotifyMap_.find(event.type); if (iter == eventNotifyMap_.end()) { DHLOGE("Invalid eventType."); + cJSON_Delete(jParam); return ERR_DH_AUDIO_NOT_FOUND_KEY; } rpcNotify_ = iter->second; rpcWaitCond_.notify_all(); + cJSON_Delete(jParam); return DH_SUCCESS; } @@ -508,25 +569,41 @@ int32_t DAudioSourceDev::TaskEnableDAudio(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_ATTRS }) || !CheckIsNum((std::string)jParam[KEY_DH_ID])) { + cJSON *jParam = cJSON_Parse(args.c_str()); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + if (!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_ATTRS })) { DHLOGE("The keys or values is invalid."); + cJSON_Delete(jParam); return ERR_DH_AUDIO_SA_PARAM_INVALID; } - int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID])); + int32_t dhId = ParseDhidFromEvent(args); if (dhId == -1) { DHLOGE("Parse dhId error."); + cJSON_Delete(jParam); return ERR_DH_AUDIO_NOT_SUPPORT; } + char *attrs = cJSON_PrintUnformatted(cJSON_GetObjectItem(jParam, KEY_ATTRS)); + if (attrs == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + std::string attrsStr(attrs); + int32_t result = 0; switch (GetDevTypeByDHId(dhId)) { case AUDIO_DEVICE_TYPE_SPEAKER: - return EnableDSpeaker(dhId, jParam[KEY_ATTRS]); + result = EnableDSpeaker(dhId, attrsStr); + break; case AUDIO_DEVICE_TYPE_MIC: - return EnableDMic(dhId, jParam[KEY_ATTRS]); + result = EnableDMic(dhId, attrsStr); + break; default: DHLOGE("Unknown audio device. dhId: %d.", dhId); - return ERR_DH_AUDIO_NOT_SUPPORT; + result = ERR_DH_AUDIO_NOT_SUPPORT; } + cJSON_Delete(jParam); + cJSON_free(attrs); + return result; } int32_t DAudioSourceDev::EnableDSpeaker(const int32_t dhId, const std::string &attrs) @@ -569,12 +646,16 @@ void DAudioSourceDev::OnEnableTaskResult(int32_t resultCode, const std::string & if (result.length() > DAUDIO_MAX_JSON_LEN || result.empty()) { return; } - json jParam = json::parse(result, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DEV_ID, KEY_DH_ID })) { + cJSON *jParam = cJSON_Parse(result.c_str()); + CHECK_NULL_VOID(jParam); + if (!CJsonParamCheck(jParam, { KEY_DEV_ID, KEY_DH_ID })) { DHLOGE("Not found the keys."); + cJSON_Delete(jParam); return; } - mgrCallback_->OnEnableAudioResult(jParam[KEY_DEV_ID], jParam[KEY_DH_ID], resultCode); + mgrCallback_->OnEnableAudioResult(std::string(cJSON_GetObjectItem(jParam, KEY_DEV_ID)->valuestring), + std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring), resultCode); + cJSON_Delete(jParam); } int32_t DAudioSourceDev::TaskDisableDAudio(const std::string &args) @@ -583,15 +664,12 @@ int32_t DAudioSourceDev::TaskDisableDAudio(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID }) || !CheckIsNum((std::string)jParam[KEY_DH_ID])) { - return ERR_DH_AUDIO_SA_PARAM_INVALID; - } - int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID])); - if (dhId == -1) { - DHLOGE("Parse dhId error."); - return ERR_DH_AUDIO_NOT_SUPPORT; - } + cJSON *jParam = cJSON_Parse(args.c_str()); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + int32_t dhId = ParseDhidFromEvent(args); + CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam, + "%s", "Parse dhId error."); + cJSON_Delete(jParam); DHLOGI("Parsed dhId = %d", dhId); switch (GetDevTypeByDHId(dhId)) { case AUDIO_DEVICE_TYPE_SPEAKER: @@ -636,12 +714,16 @@ void DAudioSourceDev::OnDisableTaskResult(int32_t resultCode, const std::string if (result.length() > DAUDIO_MAX_JSON_LEN || result.empty()) { return; } - json jParam = json::parse(result, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DEV_ID, KEY_DH_ID })) { + cJSON *jParam = cJSON_Parse(result.c_str()); + CHECK_NULL_VOID(jParam); + if (!CJsonParamCheck(jParam, { KEY_DEV_ID, KEY_DH_ID })) { DHLOGE("Not found the keys."); + cJSON_Delete(jParam); return; } - mgrCallback_->OnDisableAudioResult(jParam[KEY_DEV_ID], jParam[KEY_DH_ID], resultCode); + mgrCallback_->OnDisableAudioResult(std::string(cJSON_GetObjectItem(jParam, KEY_DEV_ID)->valuestring), + std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring), resultCode); + cJSON_Delete(jParam); } int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) @@ -670,20 +752,24 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) return ret; } - json jAudioParam; + cJSON *jAudioParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jAudioParam, ERR_DH_AUDIO_NULLPTR); to_json(jAudioParam, speaker->GetAudioParam()); std::string dhIdString = std::to_string(dhId); ret = NotifySinkDev(OPEN_SPEAKER, jAudioParam, dhIdString); if (ret != DH_SUCCESS) { DHLOGE("Notify sink open speaker failed, error code %d.", ret); + cJSON_Delete(jAudioParam); NotifyHDF(NOTIFY_OPEN_SPEAKER_RESULT, HDF_EVENT_NOTIFY_SINK_FAILED, dhId); return ret; } ret = OpenDSpeakerInner(speaker, dhId); if (ret != DH_SUCCESS) { + cJSON_Delete(jAudioParam); DHLOGE("Task Open DSpeaker Execute failed, error code %d.", ret); return ret; } + cJSON_Delete(jAudioParam); return DH_SUCCESS; } @@ -695,7 +781,7 @@ int32_t DAudioSourceDev::ParseDhidFromEvent(std::string args) if (!CJsonParamCheck(jParam, { KEY_DH_ID })) { DHLOGE("Not found the keys of dhId."); cJSON_Delete(jParam); - return -1; + return ERR_DH_AUDIO_FAILED; } cJSON *dhIdItem = cJSON_GetObjectItem(jParam, KEY_DH_ID); if (dhIdItem == NULL || !cJSON_IsString(dhIdItem)) { @@ -713,7 +799,7 @@ int32_t DAudioSourceDev::ConvertString2Int(std::string val) { if (!CheckIsNum(val)) { DHLOGE("String is not number. str:%s.", val.c_str()); - return -1; + return ERR_DH_AUDIO_FAILED; } return std::stoi(val); } @@ -741,13 +827,11 @@ int32_t DAudioSourceDev::OpenDSpeakerInner(std::shared_ptr &speaker int32_t DAudioSourceDev::CloseSpkNew(const std::string &args) { DHLOGI("Close speaker new"); - json jAudioParam; - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID })) { - DHLOGE("Task close speaker, json param check failed."); - return ERR_DH_AUDIO_FAILED; - } - NotifySinkDev(CLOSE_SPEAKER, jAudioParam, jParam[KEY_DH_ID]); + cJSON *jAudioParam = nullptr; + int32_t dhId = ParseDhidFromEvent(args); + CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, + "%s", "Parse dhId error."); + NotifySinkDev(CLOSE_SPEAKER, jAudioParam, std::to_string(dhId)); bool closeStatus = true; auto speaker = FindIoDevImpl(args); CHECK_NULL_RETURN(speaker, ERR_DH_AUDIO_NULLPTR); @@ -801,10 +885,7 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) return ERR_DH_AUDIO_SA_PARAM_INVALID; } int32_t dhId = ParseDhidFromEvent(args); - if (dhId < 0) { - DHLOGE("Failed to parse dhardware id."); - return ERR_DH_AUDIO_FAILED; - } + CHECK_AND_RETURN_RET_LOG(dhId < 0, ERR_DH_AUDIO_FAILED, "%s", "Failed to parse dhardware id."); auto mic = FindIoDevImpl(args); if (mic == nullptr) { DHLOGE("Mic device not init"); @@ -824,14 +905,15 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) return ret; } - json jAudioParam; + cJSON *jAudioParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jAudioParam, ERR_DH_AUDIO_NULLPTR); to_json(jAudioParam, mic->GetAudioParam()); - std::string dhIdString = std::to_string(dhId); - ret = NotifySinkDev(OPEN_MIC, jAudioParam, dhIdString); + ret = NotifySinkDev(OPEN_MIC, jAudioParam, std::to_string(dhId)); if (ret != DH_SUCCESS) { DHLOGE("Notify sink open mic failed, error code %d.", ret); mic->Release(); NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_NOTIFY_SINK_FAILED, dhId); + cJSON_Delete(jAudioParam); return ret; } @@ -841,22 +923,22 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) mic->Stop(); mic->Release(); NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_TRANS_START_FAILED, dhId); + cJSON_Delete(jAudioParam); return ret; } NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); + cJSON_Delete(jAudioParam); return DH_SUCCESS; } int32_t DAudioSourceDev::CloseMicNew(const std::string &args) { DHLOGI("Close mic new."); - json jAudioParam; - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID })) { - DHLOGE("Task close mic, json param check failed."); - return ERR_DH_AUDIO_FAILED; - } - NotifySinkDev(CLOSE_MIC, jAudioParam, jParam[KEY_DH_ID]); + cJSON *jAudioParam = nullptr; + int32_t dhId = ParseDhidFromEvent(args); + CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, + "%s", "Parse dhId error."); + NotifySinkDev(CLOSE_MIC, jAudioParam, std::to_string(dhId)); auto mic = FindIoDevImpl(args); CHECK_NULL_RETURN(mic, DH_SUCCESS); @@ -1078,7 +1160,7 @@ void DAudioSourceDev::OnTaskResult(int32_t resultCode, const std::string &result funcName.c_str()); } -int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const json Param, const std::string dhId) +int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const cJSON *Param, const std::string dhId) { if (!isRpcOpen_.load()) { DHLOGE("Network connection failure, rpc is not open!"); @@ -1088,28 +1170,43 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const json Par std::random_device rd; const uint32_t randomTaskCode = rd(); constexpr uint32_t eventOffset = 4; - json jParam = { { KEY_DH_ID, dhId }, - { KEY_EVENT_TYPE, type }, - { KEY_AUDIO_PARAM, Param }, - { KEY_RANDOM_TASK_CODE, std::to_string(randomTaskCode) } }; + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DH_ID, dhId.c_str()); + cJSON_AddNumberToObject(jParam, KEY_EVENT_TYPE, static_cast(type)); + cJSON *jParamCopy = cJSON_Duplicate(Param, 1); + cJSON_AddItemToObject(jParam, KEY_AUDIO_PARAM, jParamCopy); + cJSON_AddStringToObject(jParam, KEY_RANDOM_TASK_CODE, std::to_string(randomTaskCode).c_str()); DHLOGD("Notify sink dev, new engine, random task code:%s", std::to_string(randomTaskCode).c_str()); std::lock_guard devLck(ioDevMtx_); int32_t dhIdInt = ConvertString2Int(dhId); if (deviceMap_.find(dhIdInt) == deviceMap_.end()) { DHLOGE("speaker or mic dev is null. find index: %d.", dhIdInt); + cJSON_Delete(jParam); return ERR_DH_AUDIO_NULLPTR; } auto ioDev = deviceMap_[dhIdInt]; if (type == OPEN_CTRL || type == CLOSE_CTRL) { DHLOGE("In new engine mode, ctrl is not allowed."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + char *content = cJSON_PrintUnformatted(jParam); + if (content == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); return ERR_DH_AUDIO_NULLPTR; } - ioDev->SendMessage(static_cast(type), jParam.dump(), devId_); + ioDev->SendMessage(static_cast(type), std::string(content), devId_); if (type == CLOSE_SPEAKER || type == CLOSE_MIC) { // Close spk || Close mic do not need to wait RPC + cJSON_Delete(jParam); + cJSON_free(content); return DH_SUCCESS; } + cJSON_Delete(jParam); + cJSON_free(content); return WaitForRPC(static_cast(static_cast(type) + eventOffset)); } @@ -1149,15 +1246,18 @@ AudioEventType DAudioSourceDev::getEventTypeFromArgs(const std::string &args) return AudioEventType::VOLUME_SET; } -void DAudioSourceDev::to_json(json &j, const AudioParam ¶m) +void DAudioSourceDev::to_json(cJSON *j, const AudioParam ¶m) { - j = json { - { KEY_SAMPLING_RATE, param.comParam.sampleRate }, { KEY_FORMAT, param.comParam.bitFormat }, - { KEY_CHANNELS, param.comParam.channelMask }, { KEY_FRAMESIZE, param.comParam.frameSize }, - { KEY_CONTENT_TYPE, param.renderOpts.contentType }, { KEY_STREAM_USAGE, param.renderOpts.streamUsage }, - { KEY_RENDER_FLAGS, param.renderOpts.renderFlags }, { KEY_CAPTURE_FLAGS, param.captureOpts.capturerFlags }, - { KEY_SOURCE_TYPE, param.captureOpts.sourceType }, - }; + CHECK_NULL_VOID(j); + cJSON_AddNumberToObject(j, KEY_SAMPLING_RATE, param.comParam.sampleRate); + cJSON_AddNumberToObject(j, KEY_FORMAT, param.comParam.bitFormat); + cJSON_AddNumberToObject(j, KEY_CHANNELS, param.comParam.channelMask); + cJSON_AddNumberToObject(j, KEY_FRAMESIZE, param.comParam.frameSize); + cJSON_AddNumberToObject(j, KEY_CONTENT_TYPE, param.renderOpts.contentType); + cJSON_AddNumberToObject(j, KEY_STREAM_USAGE, param.renderOpts.streamUsage); + cJSON_AddNumberToObject(j, KEY_RENDER_FLAGS, param.renderOpts.renderFlags); + cJSON_AddNumberToObject(j, KEY_CAPTURE_FLAGS, param.captureOpts.capturerFlags); + cJSON_AddNumberToObject(j, KEY_SOURCE_TYPE, param.captureOpts.sourceType); } DAudioSourceDev::SourceEventHandler::SourceEventHandler(const std::shared_ptr &runner, @@ -1199,11 +1299,11 @@ void DAudioSourceDev::SourceEventHandler::ProcessEvent(const AppExecFwk::InnerEv void DAudioSourceDev::SourceEventHandler::EnableDAudioCallback(const AppExecFwk::InnerEvent::Pointer &event) { CHECK_NULL_VOID(event); - std::shared_ptr jParam = event->GetSharedObject(); - CHECK_NULL_VOID(jParam); + auto jsonString = event->GetSharedObject().get(); + CHECK_NULL_VOID(jsonString); auto sourceDevObj = sourceDev_.lock(); CHECK_NULL_VOID(sourceDevObj); - if (sourceDevObj->TaskEnableDAudio(jParam->dump()) != DH_SUCCESS) { + if (sourceDevObj->TaskEnableDAudio(*jsonString) != DH_SUCCESS) { DHLOGE("Open ctrl channel failed."); } } @@ -1211,11 +1311,11 @@ void DAudioSourceDev::SourceEventHandler::EnableDAudioCallback(const AppExecFwk: void DAudioSourceDev::SourceEventHandler::DisableDAudioCallback(const AppExecFwk::InnerEvent::Pointer &event) { CHECK_NULL_VOID(event); - std::shared_ptr jParam = event->GetSharedObject(); - CHECK_NULL_VOID(jParam); + auto jsonString = event->GetSharedObject().get(); + CHECK_NULL_VOID(jsonString); auto sourceDevObj = sourceDev_.lock(); CHECK_NULL_VOID(sourceDevObj); - if (sourceDevObj->TaskDisableDAudio(jParam->dump()) != DH_SUCCESS) { + if (sourceDevObj->TaskDisableDAudio(*jsonString) != DH_SUCCESS) { DHLOGE("Disable distributed audio failed."); } } diff --git a/services/audiomanager/managersource/src/daudio_source_manager.cpp b/services/audiomanager/managersource/src/daudio_source_manager.cpp index 3ee148a9c6e54d6da9af69a3ba1e862ae502b08f..1cefdd98e670fbf33129c616cf7849bb220cffe6 100644 --- a/services/audiomanager/managersource/src/daudio_source_manager.cpp +++ b/services/audiomanager/managersource/src/daudio_source_manager.cpp @@ -165,14 +165,29 @@ int32_t DAudioSourceManager::EnableDAudio(const std::string &devId, const std::s dhId.c_str(), version.c_str(), reqId.c_str()); CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DEV_ID, devId }, { KEY_DH_ID, dhId }, { KEY_VERSION, version }, - { KEY_ATTRS, attrs }, { KEY_REQID, reqId } }; - auto eventParam = std::make_shared(jParam); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DEV_ID, devId.c_str()); + cJSON_AddStringToObject(jParam, KEY_DH_ID, dhId.c_str()); + cJSON_AddStringToObject(jParam, KEY_VERSION, version.c_str()); + cJSON_AddStringToObject(jParam, KEY_ATTRS, attrs.c_str()); + cJSON_AddStringToObject(jParam, KEY_REQID, reqId.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + if (jsonString == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + auto eventParam = std::make_shared(jsonString); auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_MANAGER_ENABLE_DAUDIO, eventParam, 0); if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { DHLOGE("Send event failed."); + cJSON_Delete(jParam); + cJSON_free(jsonString); return ERR_DH_AUDIO_FAILED; } + cJSON_Delete(jParam); + cJSON_free(jsonString); DHLOGI("Enable audio task generate successfully."); return DH_SUCCESS; } @@ -212,13 +227,27 @@ int32_t DAudioSourceManager::DisableDAudio(const std::string &devId, const std:: DHLOGI("Disable distributed audio, devId: %s, dhId: %s, reqId: %s.", GetAnonyString(devId).c_str(), dhId.c_str(), reqId.c_str()); CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DEV_ID, devId }, { KEY_DH_ID, dhId }, { KEY_REQID, reqId } }; - auto eventParam = std::make_shared(jParam); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DEV_ID, devId.c_str()); + cJSON_AddStringToObject(jParam, KEY_DH_ID, dhId.c_str()); + cJSON_AddStringToObject(jParam, KEY_REQID, reqId.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + if (jsonString == nullptr) { + DHLOGE("Failed to create JSON data"); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + auto eventParam = std::make_shared(jsonString); auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_MANAGER_DISABLE_DAUDIO, eventParam, 0); if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { DHLOGE("Send event failed."); + cJSON_Delete(jParam); + cJSON_free(jsonString); return ERR_DH_AUDIO_FAILED; } + cJSON_Delete(jParam); + cJSON_free(jsonString); DHLOGI("Disable audio task generate successfully."); return DH_SUCCESS; } @@ -261,10 +290,10 @@ int32_t DAudioSourceManager::HandleDAudioNotify(const std::string &devId, const } // now ctrl channel is also goto here, please sure here not crash. - json jParam = json::parse(eventContent, nullptr, false); - if (JsonParamCheck(jParam, { KEY_RANDOM_TASK_CODE })) { + cJSON *jParam = cJSON_Parse(eventContent.c_str()); + if (CJsonParamCheck(jParam, { KEY_RANDOM_TASK_CODE })) { DHLOGD("Receive audio notify from sink, random task code: %s", - ((std::string)jParam[KEY_RANDOM_TASK_CODE]).c_str()); + cJSON_GetObjectItemCaseSensitive(jParam, KEY_RANDOM_TASK_CODE)->valuestring); } std::shared_ptr sourceDev = nullptr; @@ -273,6 +302,7 @@ int32_t DAudioSourceManager::HandleDAudioNotify(const std::string &devId, const auto device = audioDevMap_.find(devId); if (device == audioDevMap_.end()) { DHLOGE("Audio device not exist."); + cJSON_Delete(jParam); return ERR_DH_AUDIO_SA_DEVICE_NOT_EXIST; } sourceDev = audioDevMap_[devId].dev; @@ -280,6 +310,7 @@ int32_t DAudioSourceManager::HandleDAudioNotify(const std::string &devId, const AudioEvent audioEvent(eventType, eventContent); sourceDev->NotifyEvent(audioEvent); + cJSON_Delete(jParam); return DH_SUCCESS; } @@ -571,9 +602,9 @@ int32_t DAudioSourceManager::SourceManagerHandler::GetEventParam(const AppExecFw std::string &eventParam) { CHECK_NULL_RETURN(event, ERR_DH_AUDIO_NULLPTR); - std::shared_ptr paramObj = event->GetSharedObject(); - CHECK_NULL_RETURN(paramObj, ERR_DH_AUDIO_NULLPTR); - eventParam = paramObj->dump(); + auto jsonString = event->GetSharedObject().get(); + CHECK_NULL_RETURN(jsonString, ERR_DH_AUDIO_NULLPTR); + eventParam = *jsonString; return DH_SUCCESS; } } // DistributedHardware diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index 5c0eaa22d3093d414a2bb78ee3e3f3a81ff62f0d..de7a394de2efab9c6394841073b091f4071dba51 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -117,11 +117,23 @@ int32_t DMicDev::OpenDevice(const std::string &devId, const int32_t dhId) DHLOGI("Open mic device devId: %s, dhId: %d.", GetAnonyString(devId).c_str(), dhId); std::shared_ptr cbObj = audioEventCallback_.lock(); CHECK_NULL_RETURN(cbObj, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DH_ID, std::to_string(dhId) } }; - AudioEvent event(AudioEventType::OPEN_MIC, jParam.dump()); + + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + cJSON_Delete(jParam); + DHLOGE("Failed to create JSON data."); + return ERR_DH_AUDIO_NULLPTR; + } + std::string jsonDataStr(jsonData); + AudioEvent event(AudioEventType::OPEN_MIC, jsonDataStr); cbObj->NotifyEvent(event); DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_OPEN, devId, std::to_string(dhId), "daudio mic device open success."); + cJSON_Delete(jParam); + cJSON_free(jsonData); return DH_SUCCESS; } @@ -130,11 +142,23 @@ int32_t DMicDev::CloseDevice(const std::string &devId, const int32_t dhId) DHLOGI("Close mic device devId: %s, dhId: %d.", GetAnonyString(devId).c_str(), dhId); std::shared_ptr cbObj = audioEventCallback_.lock(); CHECK_NULL_RETURN(cbObj, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DH_ID, std::to_string(dhId) } }; - AudioEvent event(AudioEventType::CLOSE_MIC, jParam.dump()); + + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + cJSON_Delete(jParam); + DHLOGE("Failed to create JSON data."); + return ERR_DH_AUDIO_NULLPTR; + } + std::string jsonDataStr(jsonData); + AudioEvent event(AudioEventType::CLOSE_MIC, jsonDataStr); cbObj->NotifyEvent(event); DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_CLOSE, devId, std::to_string(dhId), "daudio mic device close success."); + cJSON_Delete(jParam); + cJSON_free(jsonData); curPort_ = 0; return DH_SUCCESS; } diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp index 9a98296173145761ffdaa8aa2079aced5f58afdb..9207add5fad0995eaa5f3e05821822ad45d61270 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -112,11 +112,22 @@ int32_t DSpeakerDev::OpenDevice(const std::string &devId, const int32_t dhId) std::shared_ptr cbObj = audioEventCallback_.lock(); CHECK_NULL_RETURN(cbObj, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DH_ID, std::to_string(dhId) } }; - AudioEvent event(AudioEventType::OPEN_SPEAKER, jParam.dump()); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + std::string jsonDataStr(jsonData); + AudioEvent event(AudioEventType::OPEN_SPEAKER, jsonDataStr); cbObj->NotifyEvent(event); DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_OPEN, devId, std::to_string(dhId), "daudio spk device open success."); + cJSON_Delete(jParam); + cJSON_free(jsonData); return DH_SUCCESS; } @@ -126,12 +137,23 @@ int32_t DSpeakerDev::CloseDevice(const std::string &devId, const int32_t dhId) std::shared_ptr cbObj = audioEventCallback_.lock(); CHECK_NULL_RETURN(cbObj, ERR_DH_AUDIO_NULLPTR); - json jParam = { { KEY_DH_ID, std::to_string(dhId) } }; - AudioEvent event(AudioEventType::CLOSE_SPEAKER, jParam.dump()); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_NULLPTR); + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + std::string jsonDataStr(jsonData); + AudioEvent event(AudioEventType::CLOSE_SPEAKER, jsonDataStr); cbObj->NotifyEvent(event); DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_CLOSE, devId, std::to_string(dhId), "daudio spk device close success."); curPort_ = 0; + cJSON_Delete(jParam); + cJSON_free(jsonData); return DH_SUCCESS; } diff --git a/services/audiomanager/servicesink/BUILD.gn b/services/audiomanager/servicesink/BUILD.gn index 022415421ae243117915c6bf1e8ce8ab071406d0..a1c82f040bd3e0d930b32701ac090561fe5f451f 100755 --- a/services/audiomanager/servicesink/BUILD.gn +++ b/services/audiomanager/servicesink/BUILD.gn @@ -27,7 +27,6 @@ ohos_shared_library("distributed_audio_sink") { } stack_protector_ret = true include_dirs = [ - "//third_party/json/include", "//third_party/cJSON", "${fwk_common_path}/utils/include", ] @@ -73,7 +72,7 @@ ohos_shared_library("distributed_audio_sink") { "${audio_transport_path}/senderengine:distributed_audio_encode_transport", "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk", "${services_path}/common:distributed_audio_utils", - "//third_party/cJSON:cjson", + "${third_party_path}/cJSON:cjson", ] external_deps = [ diff --git a/services/audiomanager/servicesource/BUILD.gn b/services/audiomanager/servicesource/BUILD.gn index b9b889766fde89d7ae5769607bfaff1b221f38fa..c8f0fbc788d71049418b281f160f73c65f880a05 100755 --- a/services/audiomanager/servicesource/BUILD.gn +++ b/services/audiomanager/servicesource/BUILD.gn @@ -27,7 +27,6 @@ ohos_shared_library("distributed_audio_source") { } stack_protector_ret = true include_dirs = [ - "//third_party/json/include", "//third_party/cJSON", "${driver_audio_path}/include", "${fwk_common_path}/utils/include", @@ -86,7 +85,7 @@ ohos_shared_library("distributed_audio_source") { "${distributedaudio_path}/audiohandler:distributed_audio_handler", "${services_path}/common:distributed_audio_utils", "${services_path}/hdfaudioclient:daudio_client", - "//third_party/cJSON:cjson", + "${third_party_path}/cJSON:cjson", ] external_deps = [ diff --git a/services/audiomanager/test/fuzztest/sourceserviceconfigdistributedhardware_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceserviceconfigdistributedhardware_fuzzer/BUILD.gn index 7d0150932dc34fc7970c6dfe910d1a0c0c2ecdd6..8532864c0beb49672b961931f7a0a8cf4f959f80 100644 --- a/services/audiomanager/test/fuzztest/sourceserviceconfigdistributedhardware_fuzzer/BUILD.gn +++ b/services/audiomanager/test/fuzztest/sourceserviceconfigdistributedhardware_fuzzer/BUILD.gn @@ -48,10 +48,13 @@ ohos_fuzztest("SourceServiceConfigDistributedHardwareFuzzTest") { "${innerkits_path}/native_cpp/audio_source/include", "${distributedaudio_path}/audiohandler/include", "${services_path}/audiomanager/servicesource/include", + "//third_party/cJSON", ] - deps = - [ "${services_path}/audiomanager/servicesource:distributed_audio_source" ] + deps = [ + "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn index 41bbfc6a3e4b54321ce54a9262ffbbbde119db2b..0ab65b81b1ff7f668614339ccd490be815c9d2d9 100644 --- a/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn +++ b/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn @@ -49,10 +49,13 @@ ohos_fuzztest("SourceServiceDAudioNotifyFuzzTest") { "${innerkits_path}/native_cpp/audio_source/include", "${distributedaudio_path}/audiohandler/include", "${services_path}/audiomanager/servicesource/include", + "//third_party/cJSON", ] - deps = - [ "${services_path}/audiomanager/servicesource:distributed_audio_source" ] + deps = [ + "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/audiomanager/test/fuzztest/sourceserviceinitsource_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceserviceinitsource_fuzzer/BUILD.gn index a6b8aa132b5a97dd42968c71054409ca8dddedf5..b7a82876175da6fd73b0e42c8d1d0e22071c41bd 100644 --- a/services/audiomanager/test/fuzztest/sourceserviceinitsource_fuzzer/BUILD.gn +++ b/services/audiomanager/test/fuzztest/sourceserviceinitsource_fuzzer/BUILD.gn @@ -49,11 +49,13 @@ ohos_fuzztest("SourceServiceInitSourceFuzzTest") { "${innerkits_path}/native_cpp/audio_source/include", "${distributedaudio_path}/audiohandler/include", "${services_path}/audiomanager/servicesource/include", + "//third_party/cJSON", ] deps = [ "${innerkits_path}/native_cpp/audio_source:distributed_audio_source_sdk", "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", ] defines = [ diff --git a/services/audiomanager/test/fuzztest/sourceserviceregisterdistributedhardware_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceserviceregisterdistributedhardware_fuzzer/BUILD.gn index c1cd645cb67029bba860b7e923298cffa51e8a9b..79fa4ffe9e0fa52dc390c6d1282da1954019c56d 100644 --- a/services/audiomanager/test/fuzztest/sourceserviceregisterdistributedhardware_fuzzer/BUILD.gn +++ b/services/audiomanager/test/fuzztest/sourceserviceregisterdistributedhardware_fuzzer/BUILD.gn @@ -48,10 +48,13 @@ ohos_fuzztest("SourceServiceRegisterDistributedHardwareFuzzTest") { "${innerkits_path}/native_cpp/audio_source/include", "${distributedaudio_path}/audiohandler/include", "${services_path}/audiomanager/servicesource/include", + "//third_party/cJSON", ] - deps = - [ "${services_path}/audiomanager/servicesource:distributed_audio_source" ] + deps = [ + "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/audiomanager/test/fuzztest/sourceservicereleasesource_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceservicereleasesource_fuzzer/BUILD.gn index c9288ccf744f7ba25473a8e73eeba3e290e0b216..55121a66aa46bb702fda35ad763ec42fd02abda2 100644 --- a/services/audiomanager/test/fuzztest/sourceservicereleasesource_fuzzer/BUILD.gn +++ b/services/audiomanager/test/fuzztest/sourceservicereleasesource_fuzzer/BUILD.gn @@ -49,10 +49,13 @@ ohos_fuzztest("SourceServiceReleaseSourceFuzzTest") { "${innerkits_path}/native_cpp/audio_source/include", "${distributedaudio_path}/audiohandler/include", "${services_path}/audiomanager/servicesource/include", + "//third_party/cJSON", ] - deps = - [ "${services_path}/audiomanager/servicesource:distributed_audio_source" ] + deps = [ + "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/audiomanager/test/fuzztest/sourceserviceunregisterdistributedhardware_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceserviceunregisterdistributedhardware_fuzzer/BUILD.gn index 6828a2821c60a74fed7d836449e33240fe608647..35516c502e646fbe3d9ca821c7b2f82957ba42c5 100644 --- a/services/audiomanager/test/fuzztest/sourceserviceunregisterdistributedhardware_fuzzer/BUILD.gn +++ b/services/audiomanager/test/fuzztest/sourceserviceunregisterdistributedhardware_fuzzer/BUILD.gn @@ -48,10 +48,13 @@ ohos_fuzztest("SourceServiceUnregisterDistributedHardwareFuzzTest") { "${innerkits_path}/native_cpp/audio_source/include", "${distributedaudio_path}/audiohandler/include", "${services_path}/audiomanager/servicesource/include", + "//third_party/cJSON", ] - deps = - [ "${services_path}/audiomanager/servicesource:distributed_audio_source" ] + deps = [ + "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/audiomanager/test/unittest/managersink/BUILD.gn b/services/audiomanager/test/unittest/managersink/BUILD.gn index 641605c0c62d50c0be73fc629050768c8a254171..e0355657d9815c3a492da32d570056949f0a3ed2 100644 --- a/services/audiomanager/test/unittest/managersink/BUILD.gn +++ b/services/audiomanager/test/unittest/managersink/BUILD.gn @@ -22,7 +22,6 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ - "//third_party/json/include", "${audio_framework_path}/audiopolicy/include", "${mediastandardfwk_path}/audiocapturer/include", "${mediastandardfwk_path}/audiocommon/include", @@ -64,6 +63,8 @@ ohos_unittest("DaudioSinkDevTest") { deps = [ "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk", "${services_path}/audiomanager/servicesink:distributed_audio_sink", + "${services_path}/common:distributed_audio_utils", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] @@ -99,6 +100,7 @@ ohos_unittest("DAudioSinkManagerTest") { deps = [ "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk", "${services_path}/audiomanager/servicesink:distributed_audio_sink", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp index 06ccd6c53871c03aa77b63b7500076a7098d1fc7..f77c422488dcb38fb8225bc12e4b779cec55141e 100644 --- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp +++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp @@ -18,10 +18,14 @@ #include "audio_event.h" #include "daudio_constants.h" #include "daudio_errorcode.h" +#include "daudio_log.h" #include "iservice_registry.h" #include "daudio_sink_ipc_callback_proxy.h" #include "daudio_sink_load_callback.h" +#undef DH_LOG_TAG +#define DH_LOG_TAG "DAudioSinkDevTest" + using namespace testing::ext; namespace OHOS { @@ -432,11 +436,13 @@ HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_002, TestSize.Level1) { std::string args; std::string devId = "devId"; - json j; + cJSON *j = cJSON_CreateObject(); + CHECK_NULL_VOID(j); AudioParam audioParam; sinkDev_->audioCtrlMgr_ = std::make_shared(devId, sinkDev_); EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args)); EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->from_json(j, audioParam)); + cJSON_Delete(j); } /** diff --git a/services/audiomanager/test/unittest/servicesink/BUILD.gn b/services/audiomanager/test/unittest/servicesink/BUILD.gn index b685124b6f8f62b85741e586ad0d233625f08bc0..b204c071ac7cb88a416bdd1012e8c71e541ec697 100644 --- a/services/audiomanager/test/unittest/servicesink/BUILD.gn +++ b/services/audiomanager/test/unittest/servicesink/BUILD.gn @@ -23,7 +23,6 @@ config("module_private_config") { include_dirs = [ "${audio_framework_path}/audiopolicy/include", - "//third_party/json/include", "${fwk_common_path}/utils/include", "${mediastandardfwk_path}/audiocapturer/include", "${mediastandardfwk_path}/audiocommon/include", diff --git a/services/audiomanager/test/unittest/servicesource/BUILD.gn b/services/audiomanager/test/unittest/servicesource/BUILD.gn index 116278e4c498db86d045d158cc49f78b6803ff31..6c2233d5ab738423491867f6738f0956b90ec3b0 100644 --- a/services/audiomanager/test/unittest/servicesource/BUILD.gn +++ b/services/audiomanager/test/unittest/servicesource/BUILD.gn @@ -22,7 +22,7 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ - "//third_party/json/include", + "//third_party/cJSON", "${audio_framework_path}/audiopolicy/include", "${driver_audio_path}/include", "${fwk_common_path}/utils/include", @@ -71,6 +71,7 @@ ohos_unittest("DaudioSourceServiceTest") { deps = [ "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] diff --git a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn index 24583124fe2c8bec64f02aa27dc904751e7e104d..ff0d53b2a8d187f73f7f11d332ffe88e8b60e27f 100644 --- a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn @@ -20,7 +20,7 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ - "//third_party/json/include", + "//third_party/cJSON", "${driver_audio_path}/include", "${fwk_common_path}/utils/include", "${mediastandardfwk_path}/audiocapturer/include", @@ -66,6 +66,7 @@ ohos_unittest("DaudioSourceDevTest") { "${audio_transport_path}/senderengine:distributed_audio_encode_transport", "${services_path}/audiomanager/servicesource:distributed_audio_source", "${services_path}/common:distributed_audio_utils", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] @@ -93,6 +94,7 @@ ohos_unittest("DMicDevTest") { deps = [ "${audio_transport_path}/receiverengine:distributed_audio_decode_transport", "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] @@ -117,6 +119,7 @@ ohos_unittest("DSpeakerDevTest") { deps = [ "${audio_transport_path}/senderengine:distributed_audio_encode_transport", "${services_path}/audiomanager/servicesource:distributed_audio_source", + "${third_party_path}/cJSON:cjson", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] diff --git a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp index f9101afe9266127c3dbc89b731f1e7bc61f28f66..8e666f53485bf69fb88970a7ffd16452e33f25f9 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp @@ -14,6 +14,10 @@ */ #include "daudio_source_dev_test.h" +#include "cJSON.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DAudioSourceDevTest" using namespace testing::ext; @@ -310,7 +314,7 @@ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_002, TestSize.Level1) { AudioEvent event(NOTIFY_OPEN_SPEAKER_RESULT, "result"); - EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleNotifyRPC(event)); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleNotifyRPC(event)); } /** @@ -321,8 +325,14 @@ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_002, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, HandleNotifyRPC_003, TestSize.Level1) { - json jParam = { { KEY_RESULT, DH_SUCCESS } }; - AudioEvent event(CHANGE_PLAY_STATUS, jParam.dump()); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddNumberToObject(jParam, KEY_RESULT, DH_SUCCESS); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + AudioEvent event(CHANGE_PLAY_STATUS, std::string(jsonString)); + cJSON_Delete(jParam); + cJSON_free(jsonString); EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, sourceDev_->HandleNotifyRPC(event)); event.type = NOTIFY_OPEN_SPEAKER_RESULT; @@ -402,49 +412,53 @@ HWTEST_F(DAudioSourceDevTest, TaskEnableDAudio_001, TestSize.Level1) std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(tempLongStr)); - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(jParam.dump())); - - jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, "testDhId" }, { KEY_ATTRS, "" } }; - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(jParam.dump())); - - jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN }, { KEY_ATTRS, "" } }; - EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskEnableDAudio(jParam.dump())); - - json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK }, { KEY_ATTRS, "" } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(jParam_spk.dump())); - - json jParam_mic = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_MIC }, { KEY_ATTRS, "" } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(jParam_mic.dump())); -} - -/** - * @tc.name: TaskDisableDAudio_001 - * @tc.desc: Verify the TaskDisableDAudio function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSourceDevTest, TaskDisableDAudio_001, TestSize.Level1) -{ - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio("")); - - std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio(tempLongStr)); - - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio(jParam.dump())); - - jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, "testDhId" } }; - EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskDisableDAudio(jParam.dump())); - - jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_UNKNOWN } }; - EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskDisableDAudio(jParam.dump())); - - json jParam_spk = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_spk.dump())); - - json jParam_mic = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_MIC } }; - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskDisableDAudio(jParam_mic.dump())); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DEV_ID, DEV_ID.c_str()); + cJSON_AddStringToObject(jParam, KEY_RESULT, "test_result"); + cJSON_AddStringToObject(jParam, KEY_DH_ID, "testDhId"); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskEnableDAudio(std::string(jsonString))); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskDisableDAudio(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); + + cJSON *jParam1 = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam1); + cJSON_AddStringToObject(jParam1, KEY_DEV_ID, DEV_ID.c_str()); + cJSON_AddStringToObject(jParam1, KEY_DH_ID, DH_ID_UNKNOWN.c_str()); + cJSON_AddStringToObject(jParam1, KEY_ATTRS, ""); + char *jsonString1 = cJSON_PrintUnformatted(jParam1); + CHECK_NULL_AND_FREE_VOID(jsonString1, jParam1); + EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskEnableDAudio(std::string(jsonString1))); + EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, sourceDev_->TaskDisableDAudio(std::string(jsonString1))); + cJSON_Delete(jParam1); + cJSON_free(jsonString1); + + cJSON *jParam2 = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam2); + cJSON_AddStringToObject(jParam2, KEY_DEV_ID, DEV_ID.c_str()); + cJSON_AddStringToObject(jParam2, KEY_DH_ID, DH_ID_SPK.c_str()); + cJSON_AddStringToObject(jParam2, KEY_ATTRS, ""); + char *jsonString2 = cJSON_PrintUnformatted(jParam2); + CHECK_NULL_AND_FREE_VOID(jsonString2, jParam2); + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(std::string(jsonString2))); + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskDisableDAudio(std::string(jsonString2))); + cJSON_Delete(jParam2); + cJSON_free(jsonString2); + + cJSON *jParam3 = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam3); + cJSON_AddStringToObject(jParam3, KEY_DEV_ID, DEV_ID.c_str()); + cJSON_AddStringToObject(jParam3, KEY_DH_ID, DH_ID_MIC.c_str()); + cJSON_AddStringToObject(jParam3, KEY_ATTRS, ""); + char *jsonString3 = cJSON_PrintUnformatted(jParam3); + CHECK_NULL_AND_FREE_VOID(jsonString3, jParam3); + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskEnableDAudio(std::string(jsonString3))); + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskDisableDAudio(std::string(jsonString3))); + cJSON_Delete(jParam3); + cJSON_free(jsonString3); } /** @@ -460,44 +474,37 @@ HWTEST_F(DAudioSourceDevTest, OnEnableTaskResult_001, TestSize.Level1) std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); sourceDev_->OnEnableTaskResult(DH_SUCCESS, tempLongStr, FUNC_NAME); - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; - sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - - jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; - sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - sourceDev_->OnEnableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DEV_ID, DEV_ID.c_str()); + cJSON_AddStringToObject(jParam, KEY_RESULT, "test_result"); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + sourceDev_->OnEnableTaskResult(DH_SUCCESS, std::string(jsonString), FUNC_NAME); + sourceDev_->OnDisableTaskResult(DH_SUCCESS, std::string(jsonString), FUNC_NAME); + cJSON_Delete(jParam); + cJSON_free(jsonString); + + cJSON *jParam1 = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam1); + cJSON_AddStringToObject(jParam1, KEY_DEV_ID, DEV_ID.c_str()); + cJSON_AddStringToObject(jParam1, KEY_DH_ID, DH_ID_SPK.c_str()); + char *jsonString1 = cJSON_PrintUnformatted(jParam1); + CHECK_NULL_AND_FREE_VOID(jsonString1, jParam1); + + sourceDev_->OnEnableTaskResult(DH_SUCCESS, std::string(jsonString1), FUNC_NAME); + sourceDev_->OnEnableTaskResult(ERR_DH_AUDIO_NULLPTR, std::string(jsonString1), FUNC_NAME); + sourceDev_->OnDisableTaskResult(DH_SUCCESS, std::string(jsonString1), FUNC_NAME); + sourceDev_->OnDisableTaskResult(ERR_DH_AUDIO_NULLPTR, std::string(jsonString1), FUNC_NAME); sourceDev_->mgrCallback_ = nullptr; - sourceDev_->OnEnableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); + sourceDev_->OnEnableTaskResult(DH_SUCCESS, std::string(jsonString1), FUNC_NAME); + sourceDev_->OnDisableTaskResult(DH_SUCCESS, std::string(jsonString1), FUNC_NAME); + cJSON_Delete(jParam1); + cJSON_free(jsonString1); auto mgrCb = std::make_shared(); EXPECT_NE(DH_SUCCESS, mgrCb->OnEnableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS)); -} - -/** - * @tc.name: OnDisableTaskResult_001 - * @tc.desc: Verify the OnDisableTaskResult and OnDisableAudioResult function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSourceDevTest, OnDisableTaskResult_001, TestSize.Level1) -{ - sourceDev_->OnDisableTaskResult(DH_SUCCESS, "", FUNC_NAME); - - std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); - sourceDev_->OnDisableTaskResult(DH_SUCCESS, tempLongStr, FUNC_NAME); - - json jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_RESULT, "test_result" } }; - sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - - jParam = { { KEY_DEV_ID, DEV_ID }, { KEY_DH_ID, DH_ID_SPK } }; - sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - sourceDev_->OnDisableTaskResult(ERR_DH_AUDIO_NULLPTR, jParam.dump(), FUNC_NAME); - - sourceDev_->mgrCallback_ = nullptr; - sourceDev_->OnDisableTaskResult(DH_SUCCESS, jParam.dump(), FUNC_NAME); - - auto mgrCb = std::make_shared(); EXPECT_NE(DH_SUCCESS, mgrCb->OnDisableAudioResult(DEV_ID, DH_ID_SPK, DH_SUCCESS)); } @@ -584,16 +591,22 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDSpeaker_001, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDSpeaker(ARGS)); - json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DH_ID, DH_ID_SPK.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); sourceDev_->isRpcOpen_.store(false); - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump())); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDSpeaker(std::string(jsonString))); sourceDev_->isRpcOpen_.store(true); - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump())); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDSpeaker(std::string(jsonString))); sourceDev_->rpcResult_ = DH_SUCCESS; sourceDev_->rpcNotify_ = sourceDev_->EVENT_NOTIFY_OPEN_SPK; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskOpenDSpeaker(jParam_spk.dump())); + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskOpenDSpeaker(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -620,8 +633,14 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_001, TestSize.Level1) speaker->isOpened_ = false; EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(ARGS)); - json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump())); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DH_ID, DH_ID_SPK.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -637,8 +656,14 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_002, TestSize.Level1) sourceDev_->deviceMap_[dhId] = speaker; speaker->speakerTrans_ = std::make_shared(DEV_ID, speaker); - json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; - EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump())); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DH_ID, DH_ID_SPK.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -659,8 +684,14 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDMic_001, TestSize.Level1) std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskOpenDMic(tempLongStr)); - json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDMic(jParam_mic.dump())); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DH_ID, DH_ID_MIC.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskOpenDMic(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -689,8 +720,14 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_001, TestSize.Level1) mic->isOpened_ = false; EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(ARGS)); - json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump())); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DH_ID, DH_ID_MIC.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -706,8 +743,14 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_002, TestSize.Level1) sourceDev_->deviceMap_[dhId] = mic; mic->micTrans_ = std::make_shared(DEV_ID, mic); - json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump())); + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddStringToObject(jParam, KEY_DH_ID, DH_ID_MIC.c_str()); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -747,11 +790,18 @@ HWTEST_F(DAudioSourceDevTest, TaskDMicClosed_002, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, TaskSetVolume_001, TestSize.Level1) { int32_t dhId = 3; - json jParam = { { STREAM_MUTE_STATUS, 3 }, { "dhId", "3" } }; + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddNumberToObject(jParam, STREAM_MUTE_STATUS.c_str(), 3); + cJSON_AddStringToObject(jParam, "dhId", "3"); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); auto speaker = std::make_shared(DEV_ID, sourceDev_); sourceDev_->deviceMap_[dhId] = speaker; speaker->speakerTrans_ = std::make_shared(DEV_ID, speaker); - EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskSetVolume(jParam.dump())); + EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskSetVolume(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); } /** @@ -765,9 +815,14 @@ HWTEST_F(DAudioSourceDevTest, TaskSetVolume_002, TestSize.Level1) sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(ARGS)); - json jParam = { { STREAM_MUTE_STATUS, 1 } }; - EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(jParam.dump())); - + cJSON *jParam = cJSON_CreateObject(); + CHECK_NULL_VOID(jParam); + cJSON_AddNumberToObject(jParam, STREAM_MUTE_STATUS.c_str(), 1); + char *jsonString = cJSON_PrintUnformatted(jParam); + CHECK_NULL_AND_FREE_VOID(jsonString, jParam); + EXPECT_NE(DH_SUCCESS, sourceDev_->TaskSetVolume(std::string(jsonString))); + cJSON_Delete(jParam); + cJSON_free(jsonString); sourceDev_->OnTaskResult(ERR_DH_AUDIO_NULLPTR, "", FUNC_NAME); } @@ -948,7 +1003,7 @@ HWTEST_F(DAudioSourceDevTest, NotifyHDF_003, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, NotifySinkDev_001, TestSize.Level1) { - json jAudioParam; + cJSON *jAudioParam = nullptr; int32_t dhId = 1; sourceDev_->isRpcOpen_.store(false); EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->NotifySinkDev(CLOSE_MIC, jAudioParam, DH_ID_SPK)); diff --git a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn index 4c05150475011ab23d9c5d5d57b576a11f1ac007..662e961d37a0691f19cb658205d47773114a7e1a 100644 --- a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn @@ -20,7 +20,6 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ - "//third_party/json/include", "${driver_audio_path}/include", "${fwk_common_path}/utils/include", "${mediastandardfwk_path}/audiocapturer/include", diff --git a/services/audioprocessor/test/unittest/common/directprocessor/BUILD.gn b/services/audioprocessor/test/unittest/common/directprocessor/BUILD.gn index bb633bf7aae9a85f592c74d1f50406d1f0c2b6f4..b0c396a3ec10ec78ed8e950aa2c24c51ec61ea1f 100644 --- a/services/audioprocessor/test/unittest/common/directprocessor/BUILD.gn +++ b/services/audioprocessor/test/unittest/common/directprocessor/BUILD.gn @@ -26,7 +26,6 @@ config("module_private_config") { "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", "${fwk_common_path}/utils/include", - "//third_party/json/include", ] include_dirs += [ diff --git a/services/audiotransport/receiverengine/BUILD.gn b/services/audiotransport/receiverengine/BUILD.gn index 98cc9aa94dd1e0df3664cbd828f39bd501ffeb63..226245c63c5948add781a18577a37a832b84cc6f 100644 --- a/services/audiotransport/receiverengine/BUILD.gn +++ b/services/audiotransport/receiverengine/BUILD.gn @@ -36,7 +36,6 @@ ohos_shared_library("distributed_audio_decode_transport") { include_dirs = [ "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", - "//third_party/json/include", ] include_dirs += [ diff --git a/services/audiotransport/senderengine/BUILD.gn b/services/audiotransport/senderengine/BUILD.gn index 6e18f37a28a06c8cb9f215d511eb193de20edae8..a13d10e76b03911acd3ad9e2b12c2b0e2bbc4f78 100644 --- a/services/audiotransport/senderengine/BUILD.gn +++ b/services/audiotransport/senderengine/BUILD.gn @@ -36,7 +36,6 @@ ohos_shared_library("distributed_audio_encode_transport") { include_dirs = [ "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", - "//third_party/json/include", ] include_dirs += [ diff --git a/services/audiotransport/test/unittest/receiverengine/BUILD.gn b/services/audiotransport/test/unittest/receiverengine/BUILD.gn index ed6b92cfbfb6a42b4e82740d37066e51c73a43aa..c367feb7c4f51f8934623b023d9825b58f46b9a3 100644 --- a/services/audiotransport/test/unittest/receiverengine/BUILD.gn +++ b/services/audiotransport/test/unittest/receiverengine/BUILD.gn @@ -23,7 +23,6 @@ config("module_private_config") { include_dirs = [ "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", - "//third_party/json/include", ] include_dirs += [ diff --git a/services/audiotransport/test/unittest/senderengine/BUILD.gn b/services/audiotransport/test/unittest/senderengine/BUILD.gn index aa16a660d59495b48702aa7b5da81f0249388ead..3ff8f26e3da9b397d850c44bfe6d97c46c94ff55 100644 --- a/services/audiotransport/test/unittest/senderengine/BUILD.gn +++ b/services/audiotransport/test/unittest/senderengine/BUILD.gn @@ -22,7 +22,6 @@ config("module_private_config") { include_dirs = [ "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", - "//third_party/json/include", ] include_dirs += [ diff --git a/services/common/BUILD.gn b/services/common/BUILD.gn index 3a02e57e3e1baebf53d3cbef2b7d407c22079890..6389fd67f6712f0bb84505fe6a69241dc4cb852f 100644 --- a/services/common/BUILD.gn +++ b/services/common/BUILD.gn @@ -27,9 +27,7 @@ config("daudio_common_pub_config") { } config("daudio_common_private_config") { - include_dirs = [ "//third_party/json/include" ] - - include_dirs += [ + include_dirs = [ "${common_path}/include", "${common_path}/dfx_utils/include", ] @@ -59,7 +57,7 @@ ohos_shared_library("distributed_audio_utils") { "audiodata/src/audio_data.cpp", ] - deps = [ "//third_party/cJSON:cjson" ] + deps = [ "${third_party_path}/cJSON:cjson" ] external_deps = [ "c_utils:utils", "dsoftbus:softbus_client", diff --git a/services/common/test/unittest/audiodata/BUILD.gn b/services/common/test/unittest/audiodata/BUILD.gn index 4637f731c0913350a090643e9bb488282fc4e3d0..4ade4027807432911318e9f1a792dcc90604fcd2 100644 --- a/services/common/test/unittest/audiodata/BUILD.gn +++ b/services/common/test/unittest/audiodata/BUILD.gn @@ -21,7 +21,6 @@ config("module_private_config") { include_dirs = [ "./include", - "//third_party/json/include", "${services_path}/common/audiodata/include", "${common_path}/include", ]