From b40fbf7713d845e79bbe8477ed19ef4160dc99c5 Mon Sep 17 00:00:00 2001 From: byndyx Date: Mon, 26 May 2025 16:41:43 +0800 Subject: [PATCH] add acl Signed-off-by: byndyx --- bundle.json | 1 + common/include/daudio_constants.h | 3 + common/src/daudio_util.cpp | 3 + distributedaudio.gni | 6 + .../micclient/src/dmic_client_test.cpp | 36 +---- .../managersink/include/daudio_sink_dev.h | 12 ++ .../managersink/include/daudio_sink_manager.h | 2 + .../managersink/src/daudio_sink_dev.cpp | 151 ++++++++++++++---- .../managersink/src/daudio_sink_manager.cpp | 10 +- .../managersource/include/daudio_source_dev.h | 14 +- .../include/daudio_source_manager.h | 2 + .../managersource/src/daudio_source_dev.cpp | 110 +++++++++---- .../src/daudio_source_manager.cpp | 6 + services/audiomanager/servicesink/BUILD.gn | 14 ++ .../servicesink/src/daudio_sink_service.cpp | 4 + services/audiomanager/servicesource/BUILD.gn | 17 +- .../src/daudio_source_service.cpp | 4 + .../test/unittest/sourcedevice/BUILD.gn | 1 + .../src/daudio_source_dev_test.cpp | 12 +- .../test/unittest/sourcemanager/BUILD.gn | 1 + .../src/daudio_source_ctrl_trans.cpp | 2 +- 21 files changed, 299 insertions(+), 112 deletions(-) diff --git a/bundle.json b/bundle.json index f07fe62c..ce700da4 100755 --- a/bundle.json +++ b/bundle.json @@ -48,6 +48,7 @@ "hilog", "init", "ipc", + "os_account", "player_framework", "safwk", "samgr" diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h index 48f1de95..d768a5e9 100644 --- a/common/include/daudio_constants.h +++ b/common/include/daudio_constants.h @@ -122,6 +122,9 @@ constexpr const char *KEY_EVENT_TYPE = "eventType"; constexpr const char *KEY_AUDIO_PARAM = "audioParam"; constexpr const char *KEY_ATTRS = "attrs"; constexpr const char *KEY_RANDOM_TASK_CODE = "randomTaskCode"; +constexpr const char *KEY_USERID = "userId"; +constexpr const char *KEY_TOKENID = "tokenId"; +constexpr const char *KEY_ACCOUNTID = "accountId"; constexpr const char *KEY_SAMPLING_RATE = "samplingRate"; constexpr const char *KEY_CHANNELS = "channels"; diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp index ffb487ba..b4e91177 100644 --- a/common/src/daudio_util.cpp +++ b/common/src/daudio_util.cpp @@ -68,6 +68,9 @@ std::map typeCheckMap = { std::map::value_type(KEY_DATATYPE, &DistributedHardware::IsString), std::map::value_type(KEY_CODEC_TYPE, &DistributedHardware::IsInt32), std::map::value_type(CODEC, &DistributedHardware::IsString), + std::map::value_type(KEY_USERID, &DistributedHardware::IsInt32), + std::map::value_type(KEY_TOKENID, &DistributedHardware::IsInt32), + std::map::value_type(KEY_ACCOUNTID, &DistributedHardware::IsString), }; std::map eventNameMap = { diff --git a/distributedaudio.gni b/distributedaudio.gni index d2f03bdb..8237076f 100644 --- a/distributedaudio.gni +++ b/distributedaudio.gni @@ -54,4 +54,10 @@ declare_args() { !defined(global_parts_info.security_device_security_level)) { device_security_level_control = false } + if (!defined(global_parts_info) || + defined(global_parts_info.account_os_account)) { + daudio_os_account = true + } else { + daudio_os_account = false + } } diff --git a/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp b/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp index 236fd960..ab5978b7 100644 --- a/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp +++ b/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp @@ -99,7 +99,6 @@ HWTEST_F(DMicClientTest, SetUp_001, TestSize.Level0) micClient_->SetAttrs(devId, clientCallback); AudioParam audioParam; EXPECT_NE(DH_SUCCESS, micClient_->SetUp(audioParam)); - EXPECT_EQ(DH_SUCCESS, micClient_->SetUp(audioParam_)); } /** @@ -115,27 +114,11 @@ HWTEST_F(DMicClientTest, StartCapture001, TestSize.Level0) EXPECT_NE(DH_SUCCESS, micClient_->StartCapture()); EXPECT_NE(DH_SUCCESS, micClient_->StopCapture()); - AudioStandard::AudioCapturerOptions capturerOptions = { - { - static_cast(audioParam_.comParam.sampleRate), - AudioStandard::AudioEncodingType::ENCODING_PCM, - static_cast(audioParam_.comParam.bitFormat), - static_cast(audioParam_.comParam.channelMask), - }, - { - static_cast(audioParam_.captureOpts.sourceType), - 0, - } - }; - micClient_->audioCapturer_ = AudioStandard::AudioCapturer::Create(capturerOptions); micClient_->micTrans_ = std::make_shared(); micClient_->clientStatus_ = AudioStatus::STATUS_STOP; - EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StartCapture()); - micClient_->clientStatus_ = AudioStatus::STATUS_READY; - EXPECT_NE(nullptr, micClient_->audioCapturer_); - EXPECT_EQ(DH_SUCCESS, micClient_->StartCapture()); + EXPECT_EQ(nullptr, micClient_->audioCapturer_); + EXPECT_NE(DH_SUCCESS, micClient_->StartCapture()); micClient_->micTrans_ = nullptr; - EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StartCapture()); EXPECT_NE(DH_SUCCESS, micClient_->StopCapture()); } @@ -190,21 +173,6 @@ HWTEST_F(DMicClientTest, Release001, TestSize.Level0) EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release()); micClient_->micTrans_ = std::make_shared(); - AudioStandard::AudioCapturerOptions capturerOptions = { - { - static_cast(audioParam_.comParam.sampleRate), - AudioStandard::AudioEncodingType::ENCODING_PCM, - static_cast(audioParam_.comParam.bitFormat), - static_cast(audioParam_.comParam.channelMask), - }, - { - static_cast(audioParam_.captureOpts.sourceType), - 0, - } - }; - micClient_->audioCapturer_ = AudioStandard::AudioCapturer::Create(capturerOptions); - EXPECT_NE(nullptr, micClient_->audioCapturer_); - EXPECT_EQ(DH_SUCCESS, micClient_->Release()); micClient_->audioCapturer_ = nullptr; micClient_->micTrans_ = std::make_shared(); micClient_->clientStatus_ = AudioStatus::STATUS_STOP; diff --git a/services/audiomanager/managersink/include/daudio_sink_dev.h b/services/audiomanager/managersink/include/daudio_sink_dev.h index ab17a29b..8dd06c31 100644 --- a/services/audiomanager/managersink/include/daudio_sink_dev.h +++ b/services/audiomanager/managersink/include/daudio_sink_dev.h @@ -33,6 +33,7 @@ #include "i_av_engine_provider.h" #include "i_av_receiver_engine_callback.h" #include "idaudio_sink_ipc_callback.h" +#include "device_manager_callback.h" namespace OHOS { namespace DistributedHardware { @@ -56,6 +57,11 @@ public: int32_t StopDistributedHardware(const std::string &networkId); void JudgeDeviceStatus(); void SetDevLevelStatus(bool checkStatus); + void SetUserId(int32_t value); + void SetTokenId(int32_t value); + void SetAccountId(string value); + bool CheckAclRight(); + void SetSinkTokenId(uint64_t value); private: int32_t TaskOpenDSpeaker(const std::string &args); @@ -103,6 +109,10 @@ private: std::atomic isSpkInUse_ = false; std::atomic isMicInUse_ = false; bool isDevLevelStatus_ = false; + int32_t userId_ = -1; + uint64_t tokenId_ = 0; + uint64_t sinkTokenId_ = 0; + std::string accountId_ = ""; class SinkEventHandler : public AppExecFwk::EventHandler { public: @@ -131,6 +141,8 @@ private: void NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event); int32_t GetEventParam(const AppExecFwk::InnerEvent::Pointer &event, std::string &eventParam); void ProcessEventInner(const AppExecFwk::InnerEvent::Pointer &event); + int32_t ParseValueFromEvent(std::string args, std::string key); + std::string ParseStringFromEvent(std::string args, std::string key); private: using SinkEventFunc = void (SinkEventHandler::*)(const AppExecFwk::InnerEvent::Pointer &event); diff --git a/services/audiomanager/managersink/include/daudio_sink_manager.h b/services/audiomanager/managersink/include/daudio_sink_manager.h index 99e80c23..439b5f0b 100644 --- a/services/audiomanager/managersink/include/daudio_sink_manager.h +++ b/services/audiomanager/managersink/include/daudio_sink_manager.h @@ -72,6 +72,7 @@ public: int32_t PauseDistributedHardware(const std::string &networkId); int32_t ResumeDistributedHardware(const std::string &networkId); int32_t StopDistributedHardware(const std::string &networkId); + void SetCallerTokenId(uint64_t tokenId); private: DAudioSinkManager(); @@ -109,6 +110,7 @@ private: bool isCheckSecLevel_ = false; sptr ipcSinkCallback_ = nullptr; std::shared_ptr initCallback_; + uint64_t callerTokenId_; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 97fd01f8..60be7dde 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -15,7 +15,6 @@ #include "daudio_sink_dev.h" - #include #include "daudio_constants.h" @@ -24,6 +23,11 @@ #include "daudio_sink_manager.h" #include "daudio_util.h" +#include "ohos_account_kits.h" +#include "os_account_manager.h" +#include "ipc_skeleton.h" +#include "token_setproc.h" + #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioSinkDev" @@ -121,20 +125,16 @@ int32_t DAudioSinkDev::TaskDisableDevice(const std::string &args) int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) { - DHLOGI("Open speaker device, args = %{public}s.", args.c_str()); + DHLOGI("Open speaker device"); if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } 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; - } + CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM }), ERR_DH_AUDIO_FAILED, + jParam, "Not found the keys."); 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, - "%{public}s", "Parse dhId error."); + CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam, "Parse dhId error."); std::shared_ptr speakerClient = nullptr; { std::lock_guard devLck(spkClientMutex_); @@ -143,17 +143,14 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) cJSON *audioParamJson = cJSON_GetObjectItem(jParam, KEY_AUDIO_PARAM); AudioParam audioParam; int32_t ret = from_json(audioParamJson, audioParam); - if (ret != DH_SUCCESS) { - DHLOGE("Get audio param from cjson failed, error code %{public}d.", ret); - cJSON_Delete(jParam); - return ret; - } - CHECK_NULL_FREE_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR, jParam); - ret = speakerClient->SetUp(audioParam); CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ret, jParam, - "Setup speaker failed, ret: %{public}d.", ret); - isSpkInUse_.store(true); + "Get audio param from cjson failed, error code %{public}d.", ret); cJSON_Delete(jParam); + CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed."); + CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR); + ret = speakerClient->SetUp(audioParam); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Setup speaker failed, ret: %{public}d.", ret); + isSpkInUse_.store(true); return ret; } @@ -184,7 +181,7 @@ int32_t DAudioSinkDev::TaskCloseDSpeaker(const std::string &args) int32_t DAudioSinkDev::ParseDhidFromEvent(std::string args) { - DHLOGI("ParseDhidFrom args : %{public}s", args.c_str()); + DHLOGI("ParseDhidFromEvent"); cJSON *jParam = cJSON_Parse(args.c_str()); CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED); @@ -228,6 +225,34 @@ int32_t DAudioSinkDev::ParseResultFromEvent(std::string args) return ret; } +int32_t DAudioSinkDev::SinkEventHandler::ParseValueFromEvent(std::string args, std::string key) +{ + DHLOGD("ParseValueFromEvent"); + cJSON *jParam = cJSON_Parse(args.c_str()); + CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED); + CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { key }), ERR_DH_AUDIO_FAILED, jParam, "Not found key"); + cJSON *retItem = cJSON_GetObjectItem(jParam, key.c_str()); + CHECK_AND_FREE_RETURN_RET_LOG(retItem == NULL || !cJSON_IsNumber(retItem), + ERR_DH_AUDIO_FAILED, jParam, "Not found key result"); + int32_t ret = retItem->valueint; + cJSON_Delete(jParam); + return ret; +} + +std::string DAudioSinkDev::SinkEventHandler::ParseStringFromEvent(std::string args, std::string key) +{ + DHLOGD("ParseStringFromEvent"); + cJSON *jParam = cJSON_Parse(args.c_str()); + CHECK_NULL_RETURN(jParam, ""); + + CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { key }), "", jParam, "Not found key"); + cJSON *retItem = cJSON_GetObjectItem(jParam, key.c_str()); + CHECK_AND_FREE_RETURN_RET_LOG(retItem == NULL || !cJSON_IsString(retItem), "", jParam, "Not found key result"); + auto ret = std::string(retItem->valuestring); + cJSON_Delete(jParam); + return ret; +} + int32_t DAudioSinkDev::TaskStartRender(const std::string &args) { int32_t dhId = ParseDhidFromEvent(args); @@ -261,39 +286,30 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) } 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; - } + CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM }), ERR_DH_AUDIO_FAILED, + jParam, "Not found the keys."); AudioParam audioParam; 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 %{public}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 %{public}d.", ret); int32_t dhId = ParseDhidFromEvent(args); CHECK_AND_FREE_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, jParam, "%{public}s", "Parse dhId error."); + cJSON_Delete(jParam); micDhId_ = std::to_string(dhId); std::shared_ptr micClient = nullptr; { std::lock_guard devLck(micClientMutex_); micClient = micClientMap_[dhId]; } - CHECK_NULL_FREE_RETURN(micClient, ERR_DH_AUDIO_NULLPTR, jParam); + CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed."); + CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR); ret = micClient->SetUp(audioParam); - CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, jParam, - "Set up mic failed, ret: %{public}d.", ret); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "Set up mic failed, ret: %{public}d.", ret); ret = micClient->StartCapture(); - CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, jParam, - "Start capture failed, ret: %{public}d.", ret); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "Start capture failed, ret: %{public}d.", ret); isMicInUse_.store(true); - cJSON_Delete(jParam); return ret; } @@ -735,12 +751,69 @@ void DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker(const AppExecFwk::InnerE int32_t dhId = sinkDevObj->ParseDhidFromEvent(eventParam); CHECK_AND_RETURN_LOG(dhId == -1, "%{public}s", "Parse dhId error."); + sinkDevObj->SetUserId(ParseValueFromEvent(eventParam, KEY_USERID)); + sinkDevObj->SetTokenId(ParseValueFromEvent(eventParam, KEY_TOKENID)); + sinkDevObj->SetAccountId(ParseStringFromEvent(eventParam, KEY_ACCOUNTID)); int32_t ret = sinkDevObj->TaskOpenDSpeaker(eventParam); sinkDevObj->NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, std::to_string(dhId), ret); DHLOGI("Open speaker device task end, notify source ret %{public}d.", ret); CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%{public}s", "Open speaker failed."); } +void DAudioSinkDev::SetUserId(int32_t value) +{ + userId_ = value; +} + +void DAudioSinkDev::SetTokenId(int32_t value) +{ + tokenId_ = static_cast(value); +} + +void DAudioSinkDev::SetAccountId(string value) +{ + accountId_ = value; +} + +bool DAudioSinkDev::CheckAclRight() +{ + CHECK_AND_RETURN_RET_LOG(userId_ == -1, true, "ACL not support"); + std::string sinkDevId; + int32_t ret = GetLocalDeviceNetworkId(sinkDevId); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "GetLocalDeviceNetworkId failed, ret: %{public}d", ret); +#ifdef OS_ACCOUNT_PART + std::vector ids; + ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "Get userId fail, ret: %{public}d", ret); + int32_t userId = -1; + userId = ids.empty() ? 0 : ids[0]; + AccountSA::OhosAccountInfo osAccountInfo; + ret = AccountSA::OhosAccountKits::GetInstance().GetOhosAccountInfo(osAccountInfo); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "Get accountId fail, ret: %{public}d", ret); + std::string accountId = osAccountInfo.uid_; +#endif + std::shared_ptr initCallback = std::make_shared(); + ret = DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "InitDeviceManager failed ret = %{public}d", ret); + DmAccessCaller dmSrcCaller = { + .accountId = accountId_, + .pkgName = PKG_NAME, + .networkId = devId_, + .userId = userId_, + .tokenId = tokenId_, + }; + DmAccessCallee dmDstCallee = { + .networkId = sinkDevId, + .accountId = accountId, + .userId = userId, + .tokenId = sinkTokenId_, + .pkgName = PKG_NAME, + }; + DHLOGI("CheckAclRight srcDevId: %{public}s, accountId: %{public}s, sinkDevId: %{public}s", + GetAnonyString(devId_).c_str(), GetAnonyString(accountId).c_str(), GetAnonyString(sinkDevId).c_str()); + return DeviceManager::GetInstance().CheckSinkAccessControl(dmSrcCaller, dmDstCallee); +} + void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event) { std::string eventParam; @@ -800,6 +873,9 @@ void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent cJSON_Delete(jParam); return; } + sinkDevObj->SetUserId(ParseValueFromEvent(eventParam, KEY_USERID)); + sinkDevObj->SetTokenId(ParseValueFromEvent(eventParam, KEY_TOKENID)); + sinkDevObj->SetAccountId(ParseStringFromEvent(eventParam, KEY_ACCOUNTID)); int32_t ret = sinkDevObj->TaskOpenDMic(eventParam); sinkDevObj->NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring), ret); @@ -980,5 +1056,10 @@ int32_t DAudioSinkDev::StopDistributedHardware(const std::string &networkId) NotifySourceDev(CLOSE_MIC, micDhId_, DH_SUCCESS); return DH_SUCCESS; } + +void DAudioSinkDev::SetSinkTokenId(uint64_t value) +{ + sinkTokenId_ = value; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp index 1a459634..a68b43ef 100644 --- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp @@ -143,8 +143,8 @@ void DAudioSinkManager::OnSinkDevReleased(const std::string &devId) int32_t DAudioSinkManager::HandleDAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType, const std::string &eventContent) { - DHLOGD("Receive audio event from devId: %{public}s, event type: %{public}d. event content: %{public}s.", - GetAnonyString(devId).c_str(), eventType, eventContent.c_str()); + DHLOGD("Receive audio event from devId: %{public}s, event type: %{public}d.", + GetAnonyString(devId).c_str(), eventType); if (eventContent.length() > DAUDIO_MAX_JSON_LEN || eventContent.empty() || !CheckDevIdIsLegal(devId) || eventType < 0 || eventType > MAX_EVENT_TYPE_NUM) { @@ -187,6 +187,7 @@ int32_t DAudioSinkManager::CreateAudioDevice(const std::string &devId) audioDevMap_.emplace(devId, dev); } } + dev->SetTokenId(callerTokenId_); int32_t dhId; bool isSpkOrMic = false; if (channelState_ == ChannelState::MIC_CONTROL_OPENED) { @@ -564,6 +565,11 @@ int32_t DAudioSinkManager::VerifySecurityLevel(const std::string &devId) return DH_SUCCESS; } +void DAudioSinkManager::SetCallerTokenId(uint64_t tokenId) +{ + callerTokenId_ = tokenId; +} + void DeviceInitCallback::OnRemoteDied() { DHLOGI("DeviceInitCallback OnRemoteDied"); diff --git a/services/audiomanager/managersource/include/daudio_source_dev.h b/services/audiomanager/managersource/include/daudio_source_dev.h index 22c8ebb0..df422afd 100644 --- a/services/audiomanager/managersource/include/daudio_source_dev.h +++ b/services/audiomanager/managersource/include/daudio_source_dev.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -29,6 +29,7 @@ #include "daudio_source_mgr_callback.h" #include "dmic_dev.h" #include "dspeaker_dev.h" +#include "device_manager.h" #include "iaudio_event_callback.h" #include "iaudio_data_transport.h" #include "iaudio_datatrans_callback.h" @@ -56,6 +57,7 @@ public: void SetThreadStatusFlag(bool flag); bool GetThreadStatusFlag(); void NotifyEvent(const AudioEvent &event) override; + void SetTokenId(uint64_t value); private: int32_t EnableDSpeaker(const int32_t dhId, const std::string &attrs); @@ -108,6 +110,8 @@ private: int32_t HandleSpkMmapStop(const AudioEvent &event); int32_t HandleMicMmapStart(const AudioEvent &event); int32_t HandleMicMmapStop(const AudioEvent &event); + bool CheckAclRight(); + bool GetOsAccountInfo(); #ifdef AUDIO_SUPPORT_SHARED_BUFFER void HandleAudioStatus(const AudioEvent &event); int32_t HandleAudioStart(const AudioEvent &event); @@ -155,6 +159,10 @@ private: int32_t rpcResult_ = ERR_DH_AUDIO_FAILED; uint8_t rpcNotify_ = 0; std::atomic threadStatusFlag_ = false; + std::string accountId_ = ""; + int32_t userId_ = -1; + std::string srcDevId_ = ""; + uint64_t tokenId_ = 0; class SourceEventHandler : public AppExecFwk::EventHandler { public: @@ -194,6 +202,10 @@ private: std::map eventNotifyMap_; std::shared_ptr handler_; }; + +class DeviceInitCallback : public DmInitCallback { + void OnRemoteDied() override; +}; } // DistributedHardware } // OHOS #endif // OHOS_DAUDIO_SOURCE_DEV_H \ No newline at end of file diff --git a/services/audiomanager/managersource/include/daudio_source_manager.h b/services/audiomanager/managersource/include/daudio_source_manager.h index c0cf00bf..53b1d3b9 100644 --- a/services/audiomanager/managersource/include/daudio_source_manager.h +++ b/services/audiomanager/managersource/include/daudio_source_manager.h @@ -53,6 +53,7 @@ public: int32_t UnloadAVReceiverEngineProvider(); IAVEngineProvider *getSenderProvider(); IAVEngineProvider *getReceiverProvider(); + void SetCallerTokenId(uint64_t tokenId); private: DAudioSourceManager(); @@ -95,6 +96,7 @@ private: void *pSHandler_ = nullptr; void *pRHandler_ = nullptr; std::atomic isHicollieRunning_ = true; + uint64_t callerTokenId_; class SourceManagerHandler : public AppExecFwk::EventHandler { public: diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index 380eaee8..f472c1c7 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -27,6 +27,10 @@ #include "daudio_source_manager.h" #include "daudio_util.h" +#include "ohos_account_kits.h" +#include "os_account_manager.h" +#include "ipc_skeleton.h" + #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioSourceDev" @@ -407,18 +411,68 @@ int32_t DAudioSourceDev::HandleAudioStop(const AudioEvent &event) int32_t DAudioSourceDev::HandleOpenDSpeaker(const AudioEvent &event) { DHLOGI("Open speaker device."); - CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); + CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed."); + CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); auto eventParam = std::make_shared(event); auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_OPEN_SPEAKER, eventParam, 0); - if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { - DHLOGE("Send event failed."); - return ERR_DH_AUDIO_FAILED; - } + CHECK_AND_RETURN_RET_LOG(!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE), + ERR_DH_AUDIO_FAILED, "Send event failed."); DHLOGD("Opening DSpeaker event is sent successfully."); return DH_SUCCESS; } +bool DAudioSourceDev::CheckAclRight() +{ + CHECK_AND_RETURN_RET_LOG(!GetOsAccountInfo(), false, "GetOsAccountInfo failed."); + std::shared_ptr initCallback = std::make_shared(); + int32_t ret = DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, "InitDeviceManager failed ret = %{public}d", ret); + GetLocalDeviceNetworkId(srcDevId_); + DmAccessCaller dmSrcCaller = { + .accountId = accountId_, + .pkgName = PKG_NAME, + .networkId = srcDevId_, + .userId = userId_, + .tokenId = tokenId_, + }; + DmAccessCallee dmDstCallee = { + .networkId = devId_, + }; + DHLOGI("CheckAclRight dmSrcCaller networkId: %{public}s, accountId: %{public}s, devId: %{public}s", + GetAnonyString(srcDevId_).c_str(), GetAnonyString(accountId_).c_str(), GetAnonyString(devId_).c_str()); + CHECK_AND_RETURN_RET_LOG(DeviceManager::GetInstance().CheckSrcAccessControl(dmSrcCaller, dmDstCallee), + true, "ACL pass"); + return false; +} + +bool DAudioSourceDev::GetOsAccountInfo() +{ +#ifdef OS_ACCOUNT_PART + std::vector ids; + int32_t ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, + "Get userId from active os accountIds fail, ret: %{public}d", ret); + if (ids.empty()) { + userId_ = 0; + } else { + userId_ = ids[0]; + } + + AccountSA::OhosAccountInfo osAccountInfo; + ret = AccountSA::OhosAccountKits::GetInstance().GetOhosAccountInfo(osAccountInfo); + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, false, + "Get accountId from ohos account info fail, ret: %{public}d", ret); + accountId_ = osAccountInfo.uid_; +#endif + return true; +} + +void DeviceInitCallback::OnRemoteDied() +{ + DHLOGI("DeviceInitCallback OnRemoteDied"); +} + int32_t DAudioSourceDev::HandleCloseDSpeaker(const AudioEvent &event) { DHLOGI("Close speaker device."); @@ -471,14 +525,13 @@ std::shared_ptr DAudioSourceDev::FindIoDevImpl(std::string args) int32_t DAudioSourceDev::HandleOpenDMic(const AudioEvent &event) { DHLOGI("Open mic device."); - CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); + CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed."); + CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR); auto eventParam = std::make_shared(event); auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_OPEN_MIC, eventParam, 0); - if (!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) { - DHLOGE("Send event failed."); - return ERR_DH_AUDIO_FAILED; - } + CHECK_AND_RETURN_RET_LOG(!handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE), + ERR_DH_AUDIO_FAILED, "Send event failed."); DHLOGD("Opening DMic event is sent successfully."); return DH_SUCCESS; } @@ -1392,11 +1445,7 @@ void DAudioSourceDev::OnTaskResult(int32_t resultCode, const std::string &result 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!"); - return ERR_DH_AUDIO_FAILED; - } - + CHECK_AND_RETURN_RET_LOG(!isRpcOpen_.load(), ERR_DH_AUDIO_FAILED, "Network connection failure, rpc is not open!"); std::random_device rd; const uint32_t randomTaskCode = rd(); constexpr uint32_t eventOffset = 4; @@ -1404,30 +1453,22 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const cJSON *P 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_AddNumberToObject(jParam, KEY_USERID, static_cast(userId_)); + cJSON_AddNumberToObject(jParam, KEY_TOKENID, static_cast(tokenId_)); + cJSON_AddStringToObject(jParam, KEY_ACCOUNTID, accountId_.c_str()); 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()); DHLOGI("Notify sink dev, new engine, random task code:%{public}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: %{public}d.", dhIdInt); - cJSON_Delete(jParam); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_AND_FREE_RETURN_RET_LOG(deviceMap_.find(dhIdInt) == deviceMap_.end(), ERR_DH_AUDIO_NULLPTR, + jParam, "speaker or mic dev is null. find index: %{public}d.", dhIdInt); 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; - } + CHECK_AND_FREE_RETURN_RET_LOG(type == OPEN_CTRL || type == CLOSE_CTRL, ERR_DH_AUDIO_NULLPTR, + jParam, "In new engine mode, ctrl is not allowed."); char *content = cJSON_PrintUnformatted(jParam); - if (content == nullptr) { - DHLOGE("Failed to create JSON data"); - cJSON_Delete(jParam); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_AND_FREE_RETURN_RET_LOG(content == nullptr, ERR_DH_AUDIO_NULLPTR, jParam, "Failed to create JSON data"); if (ioDev == nullptr) { cJSON_Delete(jParam); cJSON_free(content); @@ -1497,6 +1538,11 @@ void DAudioSourceDev::to_json(cJSON *j, const AudioParam ¶m) cJSON_AddNumberToObject(j, KEY_SOURCE_TYPE, param.captureOpts.sourceType); } +void DAudioSourceDev::SetTokenId(uint64_t value) +{ + tokenId_ = value; +} + DAudioSourceDev::SourceEventHandler::SourceEventHandler(const std::shared_ptr &runner, const std::shared_ptr &dev) : AppExecFwk::EventHandler(runner), sourceDev_(dev) { diff --git a/services/audiomanager/managersource/src/daudio_source_manager.cpp b/services/audiomanager/managersource/src/daudio_source_manager.cpp index a4cb3a3b..69629309 100644 --- a/services/audiomanager/managersource/src/daudio_source_manager.cpp +++ b/services/audiomanager/managersource/src/daudio_source_manager.cpp @@ -222,6 +222,7 @@ int32_t DAudioSourceManager::DoEnableDAudio(const std::string &args) DHLOGE("Source dev is nullptr."); return ERR_DH_AUDIO_FAILED; } + sourceDev->SetTokenId(callerTokenId_); int32_t result = sourceDev->EnableDAudio(dhId, attrs); return OnEnableDAudio(devId, dhId, result); } @@ -567,6 +568,11 @@ int32_t DAudioSourceManager::UnloadAVReceiverEngineProvider() return DH_SUCCESS; } +void DAudioSourceManager::SetCallerTokenId(uint64_t tokenId) +{ + callerTokenId_ = tokenId; +} + IAVEngineProvider *DAudioSourceManager::getSenderProvider() { return sendProviderPtr_; diff --git a/services/audiomanager/servicesink/BUILD.gn b/services/audiomanager/servicesink/BUILD.gn index cd83fc45..2b097064 100755 --- a/services/audiomanager/servicesink/BUILD.gn +++ b/services/audiomanager/servicesink/BUILD.gn @@ -82,6 +82,7 @@ ohos_shared_library("distributed_audio_sink") { external_deps = [ "access_token:libaccesstoken_sdk", "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", "audio_framework:audio_capturer", "audio_framework:audio_client", "audio_framework:audio_renderer", @@ -100,15 +101,28 @@ ohos_shared_library("distributed_audio_sink") { "hisysevent:libhisysevent", "hitrace:hitrace_meter", "ipc:ipc_core", + "os_account:libaccountkits", + "os_account:os_account_innerkits", "safwk:system_ability_fwk", "samgr:samgr_proxy", ] + if (daudio_os_account) { + external_deps += [ + "os_account:libaccountkits", + "os_account:os_account_innerkits", + ] + } + defines = [ "HI_LOG_ENABLE", "LOG_DOMAIN=0xD004130", ] + if (daudio_os_account) { + defines += [ "OS_ACCOUNT_PART" ] + } + if (device_security_level_control) { external_deps += [ "device_security_level:dslm_sdk" ] defines += [ "DEVICE_SECURITY_LEVEL_ENABLE" ] diff --git a/services/audiomanager/servicesink/src/daudio_sink_service.cpp b/services/audiomanager/servicesink/src/daudio_sink_service.cpp index aecd1be2..64290bdc 100644 --- a/services/audiomanager/servicesink/src/daudio_sink_service.cpp +++ b/services/audiomanager/servicesink/src/daudio_sink_service.cpp @@ -29,6 +29,8 @@ #include "daudio_sink_manager.h" #include "daudio_util.h" +#include "token_setproc.h" + #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioSinkService" @@ -75,6 +77,8 @@ bool DAudioSinkService::Init() int32_t DAudioSinkService::InitSink(const std::string ¶ms, const sptr &sinkCallback) { DAudioSinkManager::GetInstance().Init(sinkCallback); + auto callerTokenId = GetFirstCallerTokenID(); + DAudioSinkManager::GetInstance().SetCallerTokenId(callerTokenId); return DH_SUCCESS; } diff --git a/services/audiomanager/servicesource/BUILD.gn b/services/audiomanager/servicesource/BUILD.gn index 0c760dee..1a41533c 100755 --- a/services/audiomanager/servicesource/BUILD.gn +++ b/services/audiomanager/servicesource/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2024 Huawei Device Co., Ltd. +# Copyright (c) 2024-2025 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -95,11 +95,13 @@ ohos_shared_library("distributed_audio_source") { external_deps = [ "access_token:libaccesstoken_sdk", "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", "audio_framework:audio_capturer", "audio_framework:audio_client", "audio_framework:audio_renderer", "cJSON:cjson", "c_utils:utils", + "device_manager:devicemanagersdk", "distributed_hardware_fwk:distributed_av_receiver", "distributed_hardware_fwk:distributed_av_sender", "distributed_hardware_fwk:distributedhardwareutils", @@ -115,10 +117,19 @@ ohos_shared_library("distributed_audio_source") { "hitrace:hitrace_meter", "ipc:ipc_core", "ipc:ipc_single", + "os_account:libaccountkits", + "os_account:os_account_innerkits", "safwk:system_ability_fwk", "samgr:samgr_proxy", ] + if (daudio_os_account) { + external_deps += [ + "os_account:libaccountkits", + "os_account:os_account_innerkits", + ] + } + cflags = [] if (distributed_audio_extension_sa) { @@ -141,6 +152,10 @@ ohos_shared_library("distributed_audio_source") { "LOG_DOMAIN=0xD004130", ] + if (daudio_os_account) { + defines += [ "OS_ACCOUNT_PART" ] + } + if (build_variant == "root") { defines += [ "DUMP_DSPEAKERDEV_FILE", diff --git a/services/audiomanager/servicesource/src/daudio_source_service.cpp b/services/audiomanager/servicesource/src/daudio_source_service.cpp index 5f5bde03..e77ff184 100644 --- a/services/audiomanager/servicesource/src/daudio_source_service.cpp +++ b/services/audiomanager/servicesource/src/daudio_source_service.cpp @@ -30,6 +30,8 @@ #include "daudio_source_manager.h" #include "daudio_util.h" +#include "token_setproc.h" + #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioSourceService" @@ -102,6 +104,8 @@ int32_t DAudioSourceService::RegisterDistributedHardware(const std::string &devI dhId.c_str()); std::string version = param.sinkVersion; std::string attrs = param.sinkAttrs; + auto callerTokenId = GetFirstCallerTokenID(); + DAudioSourceManager::GetInstance().SetCallerTokenId(callerTokenId); return DAudioSourceManager::GetInstance().EnableDAudio(devId, dhId, version, attrs, reqId); } diff --git a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn index e671e745..1ac6a59d 100644 --- a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn @@ -74,6 +74,7 @@ ohos_unittest("DaudioSourceDevTest") { "audio_framework:audio_renderer", "cJSON:cjson", "c_utils:utils", + "device_manager:devicemanagersdk", "distributed_hardware_fwk:distributed_av_receiver", "distributed_hardware_fwk:distributed_av_sender", "distributed_hardware_fwk:distributedhardwareutils", 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 085c1789..85ca7d62 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 @@ -66,7 +66,7 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, ATTRS)); AudioEvent event = AudioEvent(OPEN_SPEAKER, "{\"dhId\":\"1\"}"); - EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDSpeaker(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleOpenDSpeaker(event)); event.type = SPEAKER_OPENED; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDSpeakerOpened(event)); event.type = CLOSE_SPEAKER; @@ -75,7 +75,7 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_001, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleDSpeakerClosed(event)); event.type = OPEN_MIC; - EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDMic(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleOpenDMic(event)); event.type = MIC_OPENED; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicOpened(event)); event.type = CLOSE_MIC; @@ -121,7 +121,7 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_002, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->EnableDAudio(DH_ID_SPK, ATTRS)); AudioEvent event = AudioEvent(OPEN_SPEAKER, "{\"dhId\":\"1\"}"); - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleOpenDSpeaker(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleOpenDSpeaker(event)); event.type = SPEAKER_OPENED; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDSpeakerOpened(event)); event.type = CLOSE_SPEAKER; @@ -130,7 +130,7 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_002, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleDSpeakerClosed(event)); event.type = OPEN_MIC; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->HandleOpenDMic(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleOpenDMic(event)); event.type = MIC_OPENED; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicOpened(event)); event.type = CLOSE_MIC; @@ -166,10 +166,10 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_003, TestSize.Level1) { sourceDev_->AwakeAudioDev(); AudioEvent event = AudioEvent(OPEN_SPEAKER, ""); - EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDSpeaker(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleOpenDSpeaker(event)); event.type = OPEN_MIC; - EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleOpenDMic(event)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->HandleOpenDMic(event)); } /** diff --git a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn index e45e7f5e..9cdb8b56 100644 --- a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn @@ -67,6 +67,7 @@ ohos_unittest("DaudioSourceMgrTest") { "audio_framework:audio_renderer", "cJSON:cjson", "c_utils:utils", + "device_manager:devicemanagersdk", "distributed_hardware_fwk:distributed_av_receiver", "distributed_hardware_fwk:distributed_av_sender", "distributed_hardware_fwk:distributedhardwareutils", diff --git a/services/audiotransport/audioctrltransport/src/daudio_source_ctrl_trans.cpp b/services/audiotransport/audioctrltransport/src/daudio_source_ctrl_trans.cpp index b024f880..a3078ba9 100644 --- a/services/audiotransport/audioctrltransport/src/daudio_source_ctrl_trans.cpp +++ b/services/audiotransport/audioctrltransport/src/daudio_source_ctrl_trans.cpp @@ -64,7 +64,7 @@ int32_t DaudioSourceCtrlTrans::Stop() int32_t DaudioSourceCtrlTrans::SendAudioEvent(uint32_t type, const std::string &content, const std::string &dstDevId) { - DHLOGI("SendAudioEvent, type: %{public}u, content: %{public}s.", type, content.c_str()); + DHLOGI("SendAudioEvent, type: %{public}u.", type); auto message = std::make_shared(type, content, dstDevId); std::string msgData = message->MarshalMessage(); return SoftbusChannelAdapter::GetInstance().SendBytesData(sessionName_, message->dstDevId_, msgData); -- Gitee