From c2cd1e0965057b5323f77a1e50695c74cb8726cf Mon Sep 17 00:00:00 2001 From: ZB Date: Sat, 30 Aug 2025 22:43:37 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8A=95=E6=92=AD=E6=97=B6=E5=A4=9A=E8=AE=BE?= =?UTF-8?q?=E5=A4=87=E5=8F=91=E5=A3=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: ZB --- .../include/audio_stream_descriptor.h | 4 + .../src/audio_stream_descriptor.cpp | 11 ++ .../native/audiocommon/include/audio_info.h | 57 +++++- .../include/audio_policy_interface.h | 4 +- .../kits/c/common/native_audiostream_base.h | 8 + .../include/audio_routing_manager_listener.h | 4 +- .../src/audio_routing_manager_listener.cpp | 19 +- .../IStandardAudioRoutingManagerListener.idl | 6 +- .../domain/router/audio_router_center.cpp | 37 +++- .../domain/router/audio_router_center.h | 6 +- .../service_main/include/audio_core_service.h | 7 +- .../service_main/src/audio_core_service.cpp | 22 +++ .../src/audio_core_service_private.cpp | 73 ++++--- services/audio_policy/test/BUILD.gn | 5 +- .../src/audio_core_service_unit_test.cpp | 184 +++++++++++++++++- .../src/audio_pipe_manager_unit_test.cpp | 28 ++- .../include/audio_policy_manager_unit_test.h | 13 +- .../src/audio_router_center_unit_test.cpp | 108 ++++++++-- .../server/include/audio_service.h | 2 +- .../server/src/audio_service.cpp | 33 ++-- .../test/unittest/audio_service_unit_test.cpp | 126 +++++++----- ...udio_service_server_src_enhance_fuzzer.cpp | 2 +- 22 files changed, 628 insertions(+), 131 deletions(-) diff --git a/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h b/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h index 80dba1c41b..620da276f7 100644 --- a/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h +++ b/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h @@ -51,6 +51,9 @@ public: AudioStreamAction streamAction_ = AUDIO_STREAM_ACTION_DEFAULT; mutable std::vector> oldDeviceDescs_ = {}; mutable std::vector> newDeviceDescs_ = {}; + // for dup device + mutable std::vector> oldDupDeviceDescs_ = {}; + mutable std::vector> newDupDeviceDescs_ = {}; std::string bundleName_ = ""; AudioStreamDescriptor() = default; @@ -67,6 +70,7 @@ public: // log and dump void Dump(std::string &dumpString); std::string GetNewDevicesTypeString(); + std::string GetNewDupDevicesTypeString(); std::string GetNewDevicesInfo(); std::string GetDeviceInfo(std::shared_ptr desc); diff --git a/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp b/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp index cdb2fd6712..c382e7de32 100644 --- a/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp +++ b/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp @@ -249,6 +249,17 @@ std::string AudioStreamDescriptor::GetNewDevicesTypeString() return out; } +std::string AudioStreamDescriptor::GetNewDupDevicesTypeString() +{ + std::string out = ""; + for (auto &desc : newDupDeviceDescs_) { + if (desc != nullptr) { + out += (desc->GetDeviceTypeString() + ":"); + } + } + return out; +} + std::string AudioStreamDescriptor::GetDeviceInfo(std::shared_ptr desc) { CHECK_AND_RETURN_RET_LOG(desc != nullptr, "", "desc is nullptr"); diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h index 65b2abc5e5..b65df648f8 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h @@ -292,7 +292,8 @@ enum AudioRingerMode { */ enum AudioPrivacyType { PRIVACY_TYPE_PUBLIC = 0, - PRIVACY_TYPE_PRIVATE = 1 + PRIVACY_TYPE_PRIVATE = 1, + PRIVACY_TYPE_SHARED = 2 }; /** @@ -1954,6 +1955,60 @@ enum XperfEventId : int32_t { XPERF_EVENT_FAULT = 3, XPERF_EVENT_MAX = 4, }; + +struct FetchDeviceInfo : public Parcelable { + StreamUsage streamUsage = STREAM_USAGE_UNKNOWN; + int32_t clientUID = -1; + RouterType routerType = ROUTER_TYPE_NONE; + AudioPipeType audioPipeType = PIPE_TYPE_UNKNOWN; + AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC; + std::string caller = ""; + + FetchDeviceInfo(StreamUsage streamUsage, int32_t clientUID, + RouterType routerType, AudioPipeType audioPipeType, AudioPrivacyType privacyType) + : streamUsage(streamUsage), clientUID(clientUID), routerType(routerType), + audioPipeType(audioPipeType), privacyType(privacyType) + {} + + FetchDeviceInfo() = default; + + bool Marshalling(Parcel &parcel) const override + { + return parcel.WriteInt32(static_cast(streamUsage)) && + parcel.WriteInt32(clientUID) && + parcel.WriteInt32(static_cast(routerType)) && + parcel.WriteInt32(static_cast(audioPipeType)) && + parcel.WriteInt32(static_cast(privacyType)) && + parcel.WriteString(caller); + } + + static FetchDeviceInfo *Unmarshalling(Parcel &parcel) + { + auto info = new(std::nothrow) FetchDeviceInfo(); + if (info == nullptr) { + return nullptr; + } + + info->streamUsage = static_cast(parcel.ReadInt32()); + info->clientUID = parcel.ReadInt32(); + info->routerType = static_cast(parcel.ReadInt32()); + info->audioPipeType = static_cast(parcel.ReadInt32()); + info->privacyType = static_cast(parcel.ReadInt32()); + info->caller = parcel.ReadString(); + + return info; + } + + void UnmarshallingSelf(Parcel &parcel) + { + streamUsage = static_cast(parcel.ReadInt32()); + clientUID = parcel.ReadInt32(); + routerType = static_cast(parcel.ReadInt32()); + audioPipeType = static_cast(parcel.ReadInt32()); + privacyType = static_cast(parcel.ReadInt32()); + caller = parcel.ReadString(); + } +}; } // namespace AudioStandard } // namespace OHOS #endif // AUDIO_INFO_H diff --git a/interfaces/inner_api/native/audiomanager/include/audio_policy_interface.h b/interfaces/inner_api/native/audiomanager/include/audio_policy_interface.h index 7a04ab3fc2..81f1778c63 100644 --- a/interfaces/inner_api/native/audiomanager/include/audio_policy_interface.h +++ b/interfaces/inner_api/native/audiomanager/include/audio_policy_interface.h @@ -109,7 +109,9 @@ public: virtual ~AudioDeviceRefiner() = default; virtual int32_t OnAudioOutputDeviceRefined(std::vector> &descs, - RouterType routerType, StreamUsage streamUsage, int32_t clientUid, AudioPipeType audioPipeType) = 0; + const FetchDeviceInfo &fetchDeviceInfo) = 0; + virtual int32_t OnAudioDupDeviceRefined(std::vector> &descs, + const FetchDeviceInfo &fetchDeviceInfo) = 0; virtual int32_t OnAudioInputDeviceRefined(std::vector> &descs, RouterType routerType, SourceType sourceType, int32_t clientUid, AudioPipeType audioPipeType) = 0; virtual int32_t GetSplitInfoRefined(std::string &splitInfo) = 0; diff --git a/interfaces/kits/c/common/native_audiostream_base.h b/interfaces/kits/c/common/native_audiostream_base.h index bc4c114c90..6f59818715 100644 --- a/interfaces/kits/c/common/native_audiostream_base.h +++ b/interfaces/kits/c/common/native_audiostream_base.h @@ -869,6 +869,14 @@ typedef enum { * @since 12 */ AUDIO_STREAM_PRIVACY_TYPE_PRIVATE = 1, + /** + * Privacy type that stream can be safely captured and screen casting + * For example,{@link OH_AudioStream_Usage#AUDIOSTREAM_USAGE_VOICE_COMMUNICATION} will not be + * captured or screen casted by third party applications under AUDIO_STREAM_PRIVACY_TYPE_PUBLIC policy. + * However, the internal catpure is allowed under the AUDIO_STREAM_PRIVACY_TYPE_SHARED policy. + * @since 21 + */ + AUDIO_STREAM_PRIVACY_TYPE_SHARED = 2, } OH_AudioStream_PrivacyType; /** diff --git a/services/audio_policy/client/service/include/audio_routing_manager_listener.h b/services/audio_policy/client/service/include/audio_routing_manager_listener.h index 245fb91929..cc3440f187 100644 --- a/services/audio_policy/client/service/include/audio_routing_manager_listener.h +++ b/services/audio_policy/client/service/include/audio_routing_manager_listener.h @@ -31,7 +31,9 @@ public: void SetDistributedRoutingRoleCallback(const std::weak_ptr &callback); void SetAudioDeviceRefinerCallback(const std::weak_ptr &callback); int32_t OnAudioOutputDeviceRefined(std::vector> &descs, - int32_t routerType, int32_t streamUsage, int32_t clientUid, int32_t audioPipeType) override; + const FetchDeviceInfo &fetchDeviceInfo) override; + int32_t OnAudioDupDeviceRefined(std::vector> &descs, + const FetchDeviceInfo &fetchDeviceInfo) override; int32_t OnAudioInputDeviceRefined(std::vector> &descs, int32_t routerType, int32_t sourceType, int32_t clientUid, int32_t audioPipeType) override; int32_t GetSplitInfoRefined(std::string &splitInfo) override; diff --git a/services/audio_policy/client/service/src/audio_routing_manager_listener.cpp b/services/audio_policy/client/service/src/audio_routing_manager_listener.cpp index a0ed547b37..7314d44997 100644 --- a/services/audio_policy/client/service/src/audio_routing_manager_listener.cpp +++ b/services/audio_policy/client/service/src/audio_routing_manager_listener.cpp @@ -60,8 +60,19 @@ void AudioRoutingManagerListener::SetAudioDeviceRefinerCallback(const std::weak_ } int32_t AudioRoutingManagerListener::OnAudioOutputDeviceRefined( - std::vector> &descs, int32_t routerType, int32_t streamUsage, - int32_t clientUid, int32_t audioPipeType) + std::vector> &descs, const FetchDeviceInfo &fetchDeviceInfo) +{ + std::unique_lock lock(deviceRefinerCallbackMutex_); + std::shared_ptr audioDeviceRefinerCallback = audioDeviceRefinerCallback_.lock(); + CHECK_AND_RETURN_RET_LOG(audioDeviceRefinerCallback != nullptr, + ERR_CALLBACK_NOT_REGISTERED, "audioDeviceRefinerCallback_ is nullptr"); + lock.unlock(); + + return audioDeviceRefinerCallback->OnAudioOutputDeviceRefined(descs, fetchDeviceInfo); +} + +int32_t AudioRoutingManagerListener::OnAudioDupDeviceRefined( + std::vector> &descs, const FetchDeviceInfo &fetchDeviceInfo) { std::unique_lock lock(deviceRefinerCallbackMutex_); std::shared_ptr audioDeviceRefinerCallback = audioDeviceRefinerCallback_.lock(); @@ -69,9 +80,7 @@ int32_t AudioRoutingManagerListener::OnAudioOutputDeviceRefined( ERR_CALLBACK_NOT_REGISTERED, "audioDeviceRefinerCallback_ is nullptr"); lock.unlock(); - return audioDeviceRefinerCallback->OnAudioOutputDeviceRefined(descs, - static_cast(routerType), static_cast(streamUsage), clientUid, - static_cast(audioPipeType)); + return audioDeviceRefinerCallback->OnAudioDupDeviceRefined(descs, fetchDeviceInfo); } int32_t AudioRoutingManagerListener::OnDistributedOutputChange(bool isRemote) diff --git a/services/audio_policy/idl/IStandardAudioRoutingManagerListener.idl b/services/audio_policy/idl/IStandardAudioRoutingManagerListener.idl index aa2b99e094..634e50dcbd 100644 --- a/services/audio_policy/idl/IStandardAudioRoutingManagerListener.idl +++ b/services/audio_policy/idl/IStandardAudioRoutingManagerListener.idl @@ -16,10 +16,14 @@ package OHOS.AudioStandard; sequenceable audio_device_descriptor..OHOS.AudioStandard.AudioDeviceDescriptor; +sequenceable audio_device_info..OHOS.AudioStandard.FetchDeviceInfo; + interface IStandardAudioRoutingManagerListener { [ipccode 1] void OnDistributedRoutingRoleChange([in] sharedptr descriptor, [in] int type); // CastType type void OnAudioOutputDeviceRefined([inout] List> descs, - [in] int routerType, [in] int streamUsage, [in] int clientUid, [in] int audioPipeType); // RouterType routerType, StreamUsage streamUsage, AudioPipeType audioPipeType + [in] FetchDeviceInfo fetchDeviceInfo); // FetchDeviceInfo fetchDeviceInfo + void OnAudioDupDeviceRefined([inout] List> descs, + [in] FetchDeviceInfo fetchDeviceInfo); // FetchDeviceInfo fetchDeviceInfo void OnAudioInputDeviceRefined([inout] List> descs, [in] int routerType, [in] int sourceType, [in] int clientUid, [in] int audioPipeType); // SourceType sourceType, AudioPipeType audioPipeType void GetSplitInfoRefined([out] String splitInfo); diff --git a/services/audio_policy/server/domain/router/audio_router_center.cpp b/services/audio_policy/server/domain/router/audio_router_center.cpp index 9b9f271a1e..4ac5897afb 100644 --- a/services/audio_policy/server/domain/router/audio_router_center.cpp +++ b/services/audio_policy/server/domain/router/audio_router_center.cpp @@ -202,8 +202,12 @@ std::vector> AudioRouterCenter::FetchOutp } if (audioDeviceRefinerCb_ != nullptr && !NeedSkipSelectAudioOutputDeviceRefined(streamUsage, descs)) { - audioDeviceRefinerCb_->OnAudioOutputDeviceRefined(descs, routerType, - callStreamUsage, clientUID, PIPE_TYPE_NORMAL_OUT); + FetchDeviceInfo fetchDeviceInfo = {}; + fetchDeviceInfo.streamUsage = callStreamUsage; + fetchDeviceInfo.routerType = routerType; + fetchDeviceInfo.clientUID = clientUID; + fetchDeviceInfo.audioPipeType = PIPE_TYPE_NORMAL_OUT; + audioDeviceRefinerCb_->OnAudioOutputDeviceRefined(descs, fetchDeviceInfo); } if (descs.size() > 0 && descs[0] != nullptr) { int32_t audioId_ = descs[0]->deviceId_; @@ -233,14 +237,33 @@ std::vector> AudioRouterCenter::FetchOutp descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice()); return descs; } - FetchDeviceInfo info = { - .streamUsage = streamUsage, - .clientUID = clientUID, - .caller = caller, - }; + FetchDeviceInfo info = {}; + info.streamUsage = streamUsage; + info.clientUID = clientUID; + info.caller = caller; return FetchOutputDevicesInner(info, routerType, bypassType, descs); } +std::vector> AudioRouterCenter::FetchDupDevices( + const FetchDeviceInfo &fetchDeviceInfo) +{ + vector> descs; + RouterType routerType = ROUTER_TYPE_NONE; + + if (audioDeviceRefinerCb_ != nullptr) { + FetchDeviceInfo info = {}; + info.streamUsage = fetchDeviceInfo.streamUsage; + info.clientUID = fetchDeviceInfo.clientUID; + info.routerType = ROUTER_TYPE_NONE; + info.audioPipeType = PIPE_TYPE_NORMAL_OUT; + info.privacyType = fetchDeviceInfo.privacyType; + + audioDeviceRefinerCb_->OnAudioDupDeviceRefined(descs, info); + } + + return descs; +} + int32_t AudioRouterCenter::NotifyDistributedOutputChange(bool isRemote) { CHECK_AND_RETURN_RET(audioDeviceRefinerCb_, SUCCESS); diff --git a/services/audio_policy/server/domain/router/audio_router_center.h b/services/audio_policy/server/domain/router/audio_router_center.h index 18c868a295..043767ddf9 100644 --- a/services/audio_policy/server/domain/router/audio_router_center.h +++ b/services/audio_policy/server/domain/router/audio_router_center.h @@ -31,11 +31,6 @@ namespace OHOS { namespace AudioStandard { -struct FetchDeviceInfo { - StreamUsage streamUsage; - int32_t clientUID; - std::string caller; -}; class AudioRouterCenter { public: @@ -46,6 +41,7 @@ public: } std::vector> FetchOutputDevices(StreamUsage streamUsage, int32_t clientUID, std::string caller, const RouterType &bypassType = RouterType::ROUTER_TYPE_NONE); + std::vector> FetchDupDevices(const FetchDeviceInfo &fetchDeviceInfo); std::shared_ptr FetchInputDevice(SourceType sourceType, int32_t clientUID, const uint32_t sessionID = 0); int32_t SetAudioDeviceRefinerCallback(const sptr &object); diff --git a/services/audio_policy/server/service/service_main/include/audio_core_service.h b/services/audio_policy/server/service/service_main/include/audio_core_service.h index 179a11ab68..5db01b0f37 100644 --- a/services/audio_policy/server/service/service_main/include/audio_core_service.h +++ b/services/audio_policy/server/service/service_main/include/audio_core_service.h @@ -312,7 +312,8 @@ private: uint32_t GetStreamPropInfoSize(const std::string &adapterName, const std::string &pipeName); int32_t CaptureConcurrentCheck(uint32_t sessionId); void SetFirstScreenOn(); - + void FetchOutputDupDevice(std::string caller, uint32_t &sessionId, + std::shared_ptr &streamDesc); private: static std::string GetEncryptAddr(const std::string &addr); int32_t FetchRendererPipesAndExecute(std::vector> &streamDescs, @@ -390,7 +391,7 @@ private: int32_t OpenRemoteAudioDevice(std::string networkId, DeviceRole deviceRole, DeviceType deviceType, std::shared_ptr remoteDeviceDescriptor); bool SelectRingerOrAlarmDevices(std::shared_ptr streamDesc); - void UpdateDualToneState(const bool &enable, const int32_t &sessionId); + void UpdateDualToneState(const bool &enable, const int32_t &sessionId, const std::string &dupSinkName = "Speaker"); int32_t MoveToLocalOutputDevice(std::vector sinkInputIds, std::shared_ptr pipeInfo, std::shared_ptr localDeviceDescriptor); bool HasLowLatencyCapability(DeviceType deviceType, bool isRemote); @@ -416,6 +417,8 @@ private: std::vector FilterSourceOutputs(int32_t sessionId); std::vector GetSourceOutputs(); void UpdateOutputRoute(std::shared_ptr streamDesc); + void UpdateRingerOrAlarmerDualDeviceOutputRouter(std::shared_ptr streamDesc); + void UpdateDupDeviceOutputRoute(std::shared_ptr streamDesc); void OnPreferredOutputDeviceUpdated(const AudioDeviceDescriptor &deviceDescriptor, const AudioStreamDeviceChangeReason reason); void OnPreferredInputDeviceUpdated(DeviceType deviceType, std::string networkId); diff --git a/services/audio_policy/server/service/service_main/src/audio_core_service.cpp b/services/audio_policy/server/service/service_main/src/audio_core_service.cpp index 10ce3b5fa5..c265aa2d4c 100644 --- a/services/audio_policy/server/service/service_main/src/audio_core_service.cpp +++ b/services/audio_policy/server/service/service_main/src/audio_core_service.cpp @@ -153,6 +153,25 @@ void AudioCoreService::DumpPipeManager(std::string &dumpString) audioOffloadStream_.Dump(dumpString); } +void AudioCoreService::FetchOutputDupDevice(std::string caller, uint32_t &sessionId, + std::shared_ptr &streamDesc) +{ + FetchDeviceInfo info = {}; + AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC; + AudioServerProxy::GetInstance().GetPrivacyType(sessionId, privacyType); + + info.streamUsage = streamDesc->rendererInfo_.streamUsage; + info.clientUID = GetRealUid(streamDesc); + info.caller = caller; + info.privacyType = privacyType; + + streamDesc->oldDupDeviceDescs_ = streamDesc->newDupDeviceDescs_; + streamDesc->newDupDeviceDescs_ = + audioRouterCenter_.FetchDupDevices(info); + HILOG_COMM_INFO("[DeviceFetchInfo] dup device %{public}s for stream %{public}d", + streamDesc->GetNewDupDevicesTypeString().c_str(), sessionId); +} + int32_t AudioCoreService::CreateRendererClient( std::shared_ptr streamDesc, uint32_t &audioFlag, uint32_t &sessionId, std::string &networkId) { @@ -184,6 +203,7 @@ int32_t AudioCoreService::CreateRendererClient( HILOG_COMM_INFO("[DeviceFetchInfo] device %{public}s for stream %{public}d", streamDesc->GetNewDevicesTypeString().c_str(), sessionId); + FetchOutputDupDevice("CreateRendererClient", sessionId, streamDesc); if (isModemStream) { return SUCCESS; } @@ -1323,6 +1343,8 @@ int32_t AudioCoreService::FetchOutputDeviceAndRoute(std::string caller, const Au streamDesc->GetNewDevicesTypeString().c_str(), streamDesc->sessionId_, streamDesc->streamStatus_); AUDIO_INFO_LOG("Target audioFlag 0x%{public}x for stream %{public}u", streamDesc->audioFlag_, streamDesc->sessionId_); + + FetchOutputDupDevice(caller + "FetchOutputDeviceAndRoute", streamDesc->sessionId_, streamDesc); } audioActiveDevice_.UpdateStreamDeviceMap("FetchOutputDeviceAndRoute"); diff --git a/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp b/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp index 435e022eb7..9005deca64 100644 --- a/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp +++ b/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp @@ -1537,37 +1537,62 @@ std::vector AudioCoreService::GetSourceOutputs() return sourceOutputs; } -void AudioCoreService::UpdateOutputRoute(std::shared_ptr streamDesc) +void AudioCoreService::UpdateRingerOrAlarmerDualDeviceOutputRouter( + std::shared_ptr streamDesc) +{ + CHECK_AND_RETURN_LOG(streamDesc != nullptr, "streamDesc is nullptr"); + StreamUsage streamUsage = streamDesc->rendererInfo_.streamUsage; + InternalDeviceType deviceType = streamDesc->newDeviceDescs_.front()->deviceType_; + if (!SelectRingerOrAlarmDevices(streamDesc)) { + audioActiveDevice_.UpdateActiveDeviceRoute(deviceType, DeviceFlag::OUTPUT_DEVICES_FLAG, + streamDesc->newDeviceDescs_.front()->deviceName_, streamDesc->newDeviceDescs_.front()->networkId_); + } + + AudioRingerMode ringerMode = audioPolicyManager_.GetRingerMode(); + if (ringerMode != RINGER_MODE_NORMAL && + IsRingerOrAlarmerDualDevicesRange(streamDesc->newDeviceDescs_.front()->getType()) && + streamDesc->newDeviceDescs_.front()->getType() != DEVICE_TYPE_SPEAKER) { + audioPolicyManager_.SetInnerStreamMute(STREAM_RING, false, streamUsage); + audioVolumeManager_.SetRingerModeMute(false); + if (audioPolicyManager_.GetSystemVolumeLevel(STREAM_RING) < + audioPolicyManager_.GetMaxVolumeLevel(STREAM_RING) / VOLUME_LEVEL_DEFAULT_SIZE) { + audioPolicyManager_.SetDoubleRingVolumeDb(STREAM_RING, + audioPolicyManager_.GetMaxVolumeLevel(STREAM_RING) / VOLUME_LEVEL_DEFAULT_SIZE); + } + } else { + audioVolumeManager_.SetRingerModeMute(true); + } + shouldUpdateDeviceDueToDualTone_ = true; +} + +void AudioCoreService::UpdateDupDeviceOutputRoute(std::shared_ptr streamDesc) { CHECK_AND_RETURN_LOG(streamDesc != nullptr, "streamDesc is nullptr"); + if (streamDesc->newDupDeviceDescs_.size() != 0) { + std::string sinkName = AudioPolicyUtils::GetInstance().GetSinkName( + streamDesc->newDupDeviceDescs_.front(), streamDesc->sessionId_); + UpdateDualToneState(false, streamDesc->sessionId_); + UpdateDualToneState(true, streamDesc->sessionId_, sinkName); + shouldUpdateDeviceDueToDualTone_ = true; + } else if (streamDesc->newDupDeviceDescs_.size() != 0) { + UpdateDualToneState(false, streamDesc->sessionId_); + } +} + +void AudioCoreService::UpdateOutputRoute(std::shared_ptr streamDesc) +{ + CHECK_AND_RETURN_LOG(streamDesc != nullptr && streamDesc->oldDeviceDescs_.size() > 0 && + streamDesc->oldDeviceDescs_.front() != nullptr, "streamDesc is nullptr"); StreamUsage streamUsage = streamDesc->rendererInfo_.streamUsage; InternalDeviceType deviceType = streamDesc->newDeviceDescs_.front()->deviceType_; AUDIO_INFO_LOG("[PipeExecInfo] Update route streamUsage:%{public}d, devicetype:[%{public}s]", streamUsage, streamDesc->GetNewDevicesTypeString().c_str()); // for collaboration, the route should be updated UpdateRouteForCollaboration(deviceType); + shouldUpdateDeviceDueToDualTone_ = false; if (Util::IsRingerOrAlarmerStreamUsage(streamUsage) && IsRingerOrAlarmerDualDevicesRange(deviceType) && !VolumeUtils::IsPCVolumeEnable()) { - if (!SelectRingerOrAlarmDevices(streamDesc)) { - audioActiveDevice_.UpdateActiveDeviceRoute(deviceType, DeviceFlag::OUTPUT_DEVICES_FLAG, - streamDesc->newDeviceDescs_.front()->deviceName_, streamDesc->newDeviceDescs_.front()->networkId_); - } - - AudioRingerMode ringerMode = audioPolicyManager_.GetRingerMode(); - if (ringerMode != RINGER_MODE_NORMAL && - IsRingerOrAlarmerDualDevicesRange(streamDesc->newDeviceDescs_.front()->getType()) && - streamDesc->newDeviceDescs_.front()->getType() != DEVICE_TYPE_SPEAKER) { - audioPolicyManager_.SetInnerStreamMute(STREAM_RING, false, streamUsage); - audioVolumeManager_.SetRingerModeMute(false); - if (audioPolicyManager_.GetSystemVolumeLevel(STREAM_RING) < - audioPolicyManager_.GetMaxVolumeLevel(STREAM_RING) / VOLUME_LEVEL_DEFAULT_SIZE) { - audioPolicyManager_.SetDoubleRingVolumeDb(STREAM_RING, - audioPolicyManager_.GetMaxVolumeLevel(STREAM_RING) / VOLUME_LEVEL_DEFAULT_SIZE); - } - } else { - audioVolumeManager_.SetRingerModeMute(true); - } - shouldUpdateDeviceDueToDualTone_ = true; + UpdateRingerOrAlarmerDualDeviceOutputRouter(streamDesc); } else { audioVolumeManager_.SetRingerModeMute(true); if (isRingDualToneOnPrimarySpeaker_ && streamUsage != STREAM_USAGE_VOICE_MODEM_COMMUNICATION) { @@ -1586,7 +1611,7 @@ void AudioCoreService::UpdateOutputRoute(std::shared_ptr } else { audioActiveDevice_.UpdateActiveDeviceRoute(deviceType, DeviceFlag::OUTPUT_DEVICES_FLAG, streamDesc->newDeviceDescs_.front()->deviceName_, streamDesc->newDeviceDescs_.front()->networkId_); - shouldUpdateDeviceDueToDualTone_ = false; + UpdateDupDeviceOutputRoute(streamDesc); } } } @@ -1706,7 +1731,7 @@ bool AudioCoreService::SelectRingerOrAlarmDevices(std::shared_ptrstreamInfo_.encoding = AudioEncodingType::ENCODING_PCM; streamDescs[i]->streamInfo_.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO; streamDescs[i]->rendererInfo_.streamUsage = STREAM_USAGE_MOVIE; - + streamDescs[i]->audioMode_ = AUDIO_MODE_RECORD; streamDescs[i]->createTimeStamp_ = ClockTime::GetCurNano(); streamDescs[i]->startTimeStamp_ = streamDescs[i]->createTimeStamp_ + 1; @@ -1383,5 +1383,187 @@ HWTEST_F(AudioCoreServiceUnitTest, SetFlagForMmapStream_001, TestSize.Level4) auto ret = coreService_->SetFlagForMmapStream(streamDesc); EXPECT_EQ(AUDIO_OUTPUT_FLAG_FAST, ret); } + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateRingerOrAlarmerDualDeviceOutputRouter_001 +* @tc.desc : Test UpdateRingerOrAlarmerDualDeviceOutputRouter() when device type is null +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateRingerOrAlarmerDualDeviceOutputRouter_001, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_001 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + audioCoreService->UpdateRingerOrAlarmerDualDeviceOutputRouter(nullptr); + + EXPECT_EQ(audioCoreService->shouldUpdateDeviceDueToDualTone_, false); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_001 end"); +} + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateRingerOrAlarmerDualDeviceOutputRouter_002 +* @tc.desc : Test UpdateRingerOrAlarmerDualDeviceOutputRouter() when device type is error +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateRingerOrAlarmerDualDeviceOutputRouter_002, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_002 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + std::shared_ptr streamDesc = std::make_shared(); + ASSERT_NE(streamDesc, nullptr); + + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + ASSERT_NE(audioDeviceDescriptor, nullptr); + + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_MIC; + streamDesc->newDeviceDescs_.push_back(std::move(audioDeviceDescriptor)); + + audioCoreService->UpdateRingerOrAlarmerDualDeviceOutputRouter(streamDesc); + + EXPECT_EQ(audioCoreService->shouldUpdateDeviceDueToDualTone_, true); + EXPECT_EQ(audioCoreService->enableDualHalToneState_, false); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_002 end"); +} + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateRingerOrAlarmerDualDeviceOutputRouter_003 +* @tc.desc : Test UpdateRingerOrAlarmerDualDeviceOutputRouter() when device type is error +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateRingerOrAlarmerDualDeviceOutputRouter_003, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_003 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + std::shared_ptr streamDesc = std::make_shared(); + ASSERT_NE(streamDesc, nullptr); + + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + ASSERT_NE(audioDeviceDescriptor, nullptr); + + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_SPEAKER; + streamDesc->newDeviceDescs_.push_back(std::move(audioDeviceDescriptor)); + + audioCoreService->UpdateRingerOrAlarmerDualDeviceOutputRouter(streamDesc); + + EXPECT_EQ(audioCoreService->audioVolumeManagger_.IsRingerModeMute(), true); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_003 end"); +} + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateRingerOrAlarmerDualDeviceOutputRouter_004 +* @tc.desc : Test UpdateRingerOrAlarmerDualDeviceOutputRouter() when device type is error +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateRingerOrAlarmerDualDeviceOutputRouter_004, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_004 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + std::shared_ptr streamDesc = std::make_shared(); + ASSERT_NE(streamDesc, nullptr); + + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + ASSERT_NE(audioDeviceDescriptor, nullptr); + + audioCoreService->SetRingerMode(AudioRingerMode::RINGER_MODE_SILENT); + + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_REMOTE_CAST; + streamDesc->newDeviceDescs_.push_back(std::move(audioDeviceDescriptor)); + + audioCoreService->UpdateRingerOrAlarmerDualDeviceOutputRouter(streamDesc); + + EXPECT_EQ(audioCoreService->audioVolumeManagger_.IsRingerModeMute(), true); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateRingerOrAlarmerDualDeviceOutputRouter_004 end"); +} + + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateDupDeviceOutputRoute_001 +* @tc.desc : Test UpdateDupDeviceOutputRoute() when device type is null +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateDupDeviceOutputRoute_001, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateDupDeviceOutputRoute_003 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + audioCoreService->UpdateDupDeviceOutputRoute(nullptr); + + EXPECT_EQ(audioCoreService->shouldUpdateDeviceDueToDualTone_, false); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateDupDeviceOutputRoute_003 end"); +} + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateDupDeviceOutputRoute_002 +* @tc.desc : Test UpdateDupDeviceOutputRoute() when device type is null +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateDupDeviceOutputRoute_002, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateDupDeviceOutputRoute_002 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + std::shared_ptr streamDesc = std::make_shared(); + ASSERT_NE(streamDesc, nullptr); + + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + ASSERT_NE(audioDeviceDescriptor, nullptr); + + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_SPEAKER; + streamDesc->newDupDeviceDescs_.push_back(std::move(audioDeviceDescriptor)); + + audioCoreService->UpdateDupDeviceOutputRoute(streamDesc); + + EXPECT_EQ(audioCoreService->shouldUpdateDeviceDueToDualTone_, true); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateDupDeviceOutputRoute_002 end"); +} + +/** +* @tc.name : Test AudioCoreService +* @tc.number: UpdateDupDeviceOutputRoute_003 +* @tc.desc : Test UpdateDupDeviceOutputRoute() when device type is null +*/ +HWTEST_F(AudioCoreServiceUnitTest, UpdateDupDeviceOutputRoute_003, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateDupDeviceOutputRoute_003 start"); + + auto audioCoreService = std::make_shared(); + ASSERT_NE(audioCoreService, nullptr); + + std::shared_ptr streamDesc = std::make_shared(); + ASSERT_NE(streamDesc, nullptr); + + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + ASSERT_NE(audioDeviceDescriptor, nullptr); + + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_SPEAKER; + streamDesc->oldDupDeviceDescs_.push_back(std::move(audioDeviceDescriptor)); + + audioCoreService->UpdateDupDeviceOutputRoute(streamDesc); + + EXPECT_EQ(audioCoreService->shouldUpdateDeviceDueToDualTone_, false); + + AUDIO_INFO_LOG("AudioCoreServiceUnitTest UpdateDupDeviceOutputRoute_003 end"); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_pipe_manager_unit_test/src/audio_pipe_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_pipe_manager_unit_test/src/audio_pipe_manager_unit_test.cpp index cf1e4e6ae5..c3f640dde4 100644 --- a/services/audio_policy/test/unittest/audio_pipe_manager_unit_test/src/audio_pipe_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_pipe_manager_unit_test/src/audio_pipe_manager_unit_test.cpp @@ -511,7 +511,7 @@ HWTEST_F(AudioPipeManagerUnitTest, GetProcessDeviceInfoBySessionId_001, TestSize desc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER; pipeInfo->streamDescriptors_.push_back(desc); audioPipeManager->AddAudioPipeInfo(pipeInfo); - + AudioStreamInfo info; uint32_t targetSessionId = 123; auto result = audioPipeManager->GetProcessDeviceInfoBySessionId(targetSessionId, info); @@ -1213,6 +1213,22 @@ HWTEST_F(AudioPipeManagerUnitTest, AudioStreamDescriptor_GetNewDevicesTypeString EXPECT_NE(out, ""); } +/** + * @tc.name: AudioStreamDescriptor_GetNewDupDevicesTypeString_001 + * @tc.desc: Test AudioStreamDescriptor GetNewDevicesTypeString. + * @tc.type: FUNC + */ +HWTEST_F(AudioPipeManagerUnitTest, AudioStreamDescriptor_GetNewDupDevicesTypeString_001, TestSize.Level2) +{ + std::shared_ptr desc = std::make_shared(); + desc->sessionId_ = 1; + desc->newDupDeviceDescs_.push_back(std::make_shared()); + desc->newDupDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER; + + std::string out = desc->GetNewDupDevicesTypeString(); + EXPECT_EQ(out, "SPEAKER"); +} + /** * @tc.name: GetAllCapturerStreamDescs_001 * @tc.desc: Test GetAllCapturerStreamDescs when finding capture stream descriptors. @@ -1223,7 +1239,7 @@ HWTEST_F(AudioPipeManagerUnitTest, GetAllCapturerStreamDescs_001, TestSize.Level { auto audioPipeManager = AudioPipeManager::GetPipeManager(); audioPipeManager->curPipeList_.clear(); - + std::shared_ptr pipeInfo = std::make_shared(); pipeInfo->pipeRole_ = PIPE_ROLE_INPUT; std::shared_ptr desc1 = std::make_shared(); @@ -1232,14 +1248,14 @@ HWTEST_F(AudioPipeManagerUnitTest, GetAllCapturerStreamDescs_001, TestSize.Level desc2->audioMode_ = AUDIO_MODE_RECORD; pipeInfo->streamDescriptors_.push_back(desc1); pipeInfo->streamDescriptors_.push_back(desc2); - + audioPipeManager->AddAudioPipeInfo(pipeInfo); auto result = audioPipeManager->GetAllCapturerStreamDescs(); EXPECT_EQ(result.size(), 2); EXPECT_EQ(result[0], desc1); EXPECT_EQ(result[1], desc2); } - + /** * @tc.name: GetAllCapturerStreamDescs_002 * @tc.desc: Test GetAllCapturerStreamDescs when no capture stream descriptors are found. @@ -1250,14 +1266,14 @@ HWTEST_F(AudioPipeManagerUnitTest, GetAllCapturerStreamDescs_002, TestSize.Level { auto audioPipeManager = AudioPipeManager::GetPipeManager(); audioPipeManager->curPipeList_.clear(); - + std::shared_ptr pipeInfo = std::make_shared(); pipeInfo->pipeRole_ = PIPE_ROLE_OUTPUT; std::shared_ptr desc1 = std::make_shared(); std::shared_ptr desc2 = std::make_shared(); pipeInfo->streamDescriptors_.push_back(desc1); pipeInfo->streamDescriptors_.push_back(desc2); - + audioPipeManager->AddAudioPipeInfo(pipeInfo); auto result = audioPipeManager->GetAllCapturerStreamDescs(); EXPECT_EQ(result.size(), 0); diff --git a/services/audio_policy/test/unittest/audio_policy_manager_unit_test/include/audio_policy_manager_unit_test.h b/services/audio_policy/test/unittest/audio_policy_manager_unit_test/include/audio_policy_manager_unit_test.h index eba41459e3..1dab774a4f 100644 --- a/services/audio_policy/test/unittest/audio_policy_manager_unit_test/include/audio_policy_manager_unit_test.h +++ b/services/audio_policy/test/unittest/audio_policy_manager_unit_test/include/audio_policy_manager_unit_test.h @@ -56,8 +56,19 @@ public: class ConcreteAudioDeviceRefiner : public AudioDeviceRefiner { public: virtual int32_t OnAudioOutputDeviceRefined(std::vector> &descs, - RouterType routerType, StreamUsage streamUsage, int32_t clientUid, AudioPipeType audioPipeType) + const FetchDeviceInfo &fetchDeviceInfo) override { return 0; } + virtual int32_t OnAudioDupDeviceRefined(std::vector> &descs, + const FetchDeviceInfo &fetchDeviceInfo) override + { + std::shared_ptr desc = std::make_shared(); + if (desc == nullptr) { + return 0; + } + desc->deviceType_ = DEVICE_TYPE_SPEAKER; + descs.push_back(std::move(desc)); + return 0; + } virtual int32_t OnAudioInputDeviceRefined(std::vector> &descs, RouterType routerType, SourceType sourceType, int32_t clientUid, AudioPipeType audioPipeType) override {return 0;} diff --git a/services/audio_policy/test/unittest/audio_router_center_unit_test/src/audio_router_center_unit_test.cpp b/services/audio_policy/test/unittest/audio_router_center_unit_test/src/audio_router_center_unit_test.cpp index 8d0a0ba4f3..4ad0877f95 100644 --- a/services/audio_policy/test/unittest/audio_router_center_unit_test/src/audio_router_center_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_router_center_unit_test/src/audio_router_center_unit_test.cpp @@ -18,10 +18,15 @@ #include "audio_policy_log.h" #include "audio_zone_service.h" +#include +#include + #include #include #include using namespace testing::ext; +using namespace testing; +using ::testing::_; namespace OHOS { namespace AudioStandard { @@ -141,6 +146,79 @@ HWTEST(AudioRouterCenterUnitTest, AudioRouterCenter_006, TestSize.Level1) EXPECT_FALSE(audioRouterCenter.IsConfigRouterStrategy(type)); } +class MockStandardAudioRoutingManagerListener : public StandardAudioRoutingManagerListenerStub { +public: + MockStandardAudioRoutingManagerListener() {}; + virtual ~MockStandardAudioRoutingManagerListener() {}; + + MOCK_METHOD(int32_t, OnAudioDupDeviceRefined, (std::vector> &descs, + const FetchDeviceInfo &fetchDeviceInfo), (override)); + MOCK_METHOD(int32_t, OnAudioOutputDeviceRefined, (std::vector> &descs, + const FetchDeviceInfo &fetchDeviceInfo), (override)); + MOCK_METHOD(int32_t, OnAudioInputDeviceRefined, (std::vector> &descs, + int32_t routerType, int32_t sourceType, int32_t clientUid, int32_t audioPipeType), (override)); + MOCK_METHOD(int32_t, GetSplitInfoRefined, (std::string &splitInfo), (override)); + MOCK_METHOD(int32_t, OnDistributedOutputChange, (bool isRemote), (override)); + MOCK_METHOD(int32_t, OnDistributedRoutingRoleChange, + (const std::shared_ptr &descriptor, int32_t type), (override)); +}; + +/** + * @tc.name : Test FetchDupDevice. + * @tc.number: FetchDupDevices_001 + * @tc.desc : Test FetchDupDevices interface. + */ +HWTEST(AudioRouterCenterUnitTest, FetchDupDevices_001, TestSize.Level1) +{ + AudioRouterCenter audioRouterCenter; + audioRouterCenter.audioDeviceRefinerCb_ = nullptr; + + FetchDeviceInfo fetchDeviceInfo = {}; + fetchDeviceInfo.streamUsage = STREAM_USAGE_MUSIC; + fetchDeviceInfo.clientUID = 1000; + fetchDeviceInfo.routerType = ROUTER_TYPE_DEFAULT; + fetchDeviceInfo.caller = "caller"; + auto result = audioRouterCenter.FetchDupDevices(fetchDeviceInfo); + + EXPECT_EQ(result.size(), 0); +} + +/** + * @tc.name : Test FetchDupDevice. + * @tc.number: FetchDupDevices_002 + * @tc.desc : Test FetchDupDevices interface. + */ +HWTEST(AudioRouterCenterUnitTest, FetchDupDevices_002, TestSize.Level1) +{ + AudioRouterCenter audioRouterCenter; + MockStandardAudioRoutingManagerListener mockCallback; + audioRouterCenter.audioDeviceRefinerCb_ = &mockCallback; + + std::vector> expectDescs; + std::shared_ptr desc = std::make_shared(); + desc->deviceType_ = DEVICE_TYPE_SPEAKER; + expectDescs.push_back(desc); + + EXPECT_CALL(mockCallback, OnAudioDupDeviceRefined(_, _)) + .Times(1) + .WillOnce(Invoke([&](std::vector> &descs, + const FetchDeviceInfo &fetchDeviceInfo) -> int32_t { + descs = expectDescs; + + return 0; + })); + + FetchDeviceInfo fetchDeviceInfo = {}; + fetchDeviceInfo.streamUsage = STREAM_USAGE_MUSIC; + fetchDeviceInfo.clientUID = 1000; + fetchDeviceInfo.routerType = ROUTER_TYPE_DEFAULT; + fetchDeviceInfo.caller = "caller"; + auto result = audioRouterCenter.FetchDupDevices(fetchDeviceInfo); + + EXPECT_EQ(result, expectDescs); +} + + /** * @tc.name : Test FetchRingRenderDevices. * @tc.number: FetchRingRenderDevices_001 @@ -192,7 +270,7 @@ public: std::shared_ptr callRenderRet_; std::shared_ptr callCaptureRet_; std::shared_ptr recordCaptureRet_; - + MockRouter(RouterType type = ROUTER_TYPE_DEFAULT, std::shared_ptr mediaRenderRet = nullptr, std::shared_ptr callRenderRet = nullptr, @@ -203,7 +281,7 @@ public: callRenderRet_(std::move(callRenderRet)), callCaptureRet_(std::move(callCaptureRet)), recordCaptureRet_(std::move(recordCaptureRet)) {} - + std::shared_ptr GetMediaRenderDevice(StreamUsage, int32_t) override { return mediaRenderRet_; @@ -257,7 +335,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchMediaRenderDevice_desc_nullptr, TestSize. EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchMediaRenderDevice. * @tc.number: FetchMediaRenderDevice_002 @@ -276,7 +354,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchMediaRenderDevice_deviceType_NONE, TestSi EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchMediaRenderDevice. * @tc.number: FetchMediaRenderDevice_003 @@ -295,7 +373,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchMediaRenderDevice_deviceType_valid, TestS EXPECT_EQ(result, validDesc); EXPECT_EQ(rtype, ROUTER_TYPE_DEFAULT); } - + /** * @tc.name : Test FetchMediaRenderDevice. * @tc.number: FetchMediaRenderDevice_004 @@ -314,7 +392,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchMediaRenderDevice_bypassType_skip, TestSi EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchCallRenderDevice. * @tc.number: FetchCallRenderDevice_001 @@ -332,7 +410,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallRenderDevice_desc_nullptr, TestSize.L EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchCallRenderDevice. * @tc.number: FetchCallRenderDevice_002 @@ -352,7 +430,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallRenderDevice_deviceType_NONE, TestSiz EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchCallRenderDevice. * @tc.number: FetchCallRenderDevice_003 @@ -372,7 +450,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallRenderDevice_deviceType_valid, TestSi EXPECT_EQ(result, validDesc); EXPECT_EQ(rtype, ROUTER_TYPE_DEFAULT); } - + /** * @tc.name : Test FetchCallRenderDevice. * @tc.number: FetchCallRenderDevice_004 @@ -392,7 +470,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallRenderDevice_bypassType_skip, TestSiz EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchCallCaptureDevice. * @tc.number: FetchCallCaptureDevice_001 @@ -409,7 +487,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallCaptureDevice_desc_nullptr, TestSize. EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchCallCaptureDevice. * @tc.number: FetchCallCaptureDevice_002 @@ -428,7 +506,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallCaptureDevice_deviceType_NONE, TestSi EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchCallCaptureDevice. * @tc.number: FetchCallCaptureDevice_003 @@ -447,7 +525,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchCallCaptureDevice_deviceType_valid, TestS EXPECT_EQ(result, validDesc); EXPECT_EQ(rtype, ROUTER_TYPE_DEFAULT); } - + /** * @tc.name : Test FetchVoiceMessageCaptureDevice. * @tc.number: FetchVoiceMessageCaptureDevice_001 @@ -464,7 +542,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchVoiceMessageCaptureDevice_desc_nullptr, T EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchVoiceMessageCaptureDevice. * @tc.number: FetchVoiceMessageCaptureDevice_002 @@ -483,7 +561,7 @@ HWTEST(AudioRouterCenterUnitTest, FetchVoiceMessageCaptureDevice_deviceType_NONE EXPECT_EQ(result->deviceType_, DEVICE_TYPE_NONE); EXPECT_EQ(rtype, ROUTER_TYPE_NONE); } - + /** * @tc.name : Test FetchVoiceMessageCaptureDevice. * @tc.number: FetchVoiceMessageCaptureDevice_003 diff --git a/services/audio_service/server/include/audio_service.h b/services/audio_service/server/include/audio_service.h index 2b816d7ccb..0ef95a5f7b 100644 --- a/services/audio_service/server/include/audio_service.h +++ b/services/audio_service/server/include/audio_service.h @@ -185,7 +185,7 @@ private: bool ShouldBeInnerCap(const AudioProcessConfig &rendererConfig, std::set &beCapIds); bool CheckShouldCap(const AudioProcessConfig &rendererConfig, int32_t innerCapId); #endif - bool ShouldBeDualTone(const AudioProcessConfig &config); + bool ShouldBeDualTone(const AudioProcessConfig &config, const std::string &dupSinkName); #ifdef HAS_FEATURE_INNERCAPTURER int32_t OnInitInnerCapList(int32_t innerCapId); // for first InnerCap filter take effect. int32_t OnUpdateInnerCapList(int32_t innerCapId); // for some InnerCap filter has already take effect. diff --git a/services/audio_service/server/src/audio_service.cpp b/services/audio_service/server/src/audio_service.cpp index 4b01d8702a..066eab2625 100644 --- a/services/audio_service/server/src/audio_service.cpp +++ b/services/audio_service/server/src/audio_service.cpp @@ -368,7 +368,7 @@ bool AudioService::UpdateResumeInterruptEventMap(const uint32_t sessionId, } return true; } - + bool AudioService::RemoveResumeInterruptEventMap(const uint32_t sessionId) { std::lock_guard lock(resumeInterruptEventMutex_); @@ -379,7 +379,7 @@ bool AudioService::RemoveResumeInterruptEventMap(const uint32_t sessionId) resumeInterruptEventMap_.erase(sessionId); return true; } - + bool AudioService::IsStreamInterruptResume(const uint32_t sessionId) { InterruptEventInternal interruptEvent; @@ -397,7 +397,7 @@ bool AudioService::IsStreamInterruptResume(const uint32_t sessionId) resumeInterruptEventMap_.erase(sessionId); return false; } - + bool AudioService::UpdatePauseInterruptEventMap(const uint32_t sessionId, InterruptEventInternal interruptEvent) { @@ -410,7 +410,7 @@ bool AudioService::UpdatePauseInterruptEventMap(const uint32_t sessionId, } return true; } - + bool AudioService::RemovePauseInterruptEventMap(const uint32_t sessionId) { std::lock_guard lock(pauseInterruptEventMutex_); @@ -421,7 +421,7 @@ bool AudioService::RemovePauseInterruptEventMap(const uint32_t sessionId) pauseInterruptEventMap_.erase(sessionId); return true; } - + bool AudioService::IsStreamInterruptPause(const uint32_t sessionId) { std::lock_guard lock(pauseInterruptEventMutex_); @@ -438,7 +438,7 @@ bool AudioService::IsStreamInterruptPause(const uint32_t sessionId) AUDIO_INFO_LOG("sessionId:%{public}u Pause Timeout!!!", sessionId); return false; } - + bool AudioService::IsInSwitchStreamMap(uint32_t sessionId, SwitchState &switchState) { std::lock_guard lock(audioSwitchStreamMutex_); @@ -449,7 +449,7 @@ bool AudioService::IsInSwitchStreamMap(uint32_t sessionId, SwitchState &switchSt switchState = iter->second; return true; } - + bool AudioService::UpdateSwitchStreamMap(uint32_t sessionId, SwitchState switchState) { std::lock_guard lock(audioSwitchStreamMutex_); @@ -461,7 +461,7 @@ bool AudioService::UpdateSwitchStreamMap(uint32_t sessionId, SwitchState switchS iter->second = switchState; return true; } - + void AudioService::RemoveSwitchStreamMap(uint32_t sessionId) { std::lock_guard lock(audioSwitchStreamMutex_); @@ -470,7 +470,7 @@ void AudioService::RemoveSwitchStreamMap(uint32_t sessionId) audioSwitchStreamMap_.erase(sessionId); } } - + bool AudioService::IsBackgroundCaptureAllowed(uint32_t sessionId) { std::lock_guard lock(backgroundCaptureMutex_); @@ -484,7 +484,7 @@ bool AudioService::IsBackgroundCaptureAllowed(uint32_t sessionId) } return false; } - + bool AudioService::UpdateBackgroundCaptureMap(uint32_t sessionId, bool res) { std::lock_guard lock(backgroundCaptureMutex_); @@ -496,7 +496,7 @@ bool AudioService::UpdateBackgroundCaptureMap(uint32_t sessionId, bool res) iter->second = res; return true; } - + void AudioService::RemoveBackgroundCaptureMap(uint32_t sessionId) { std::lock_guard lock(backgroundCaptureMutex_); @@ -505,7 +505,7 @@ void AudioService::RemoveBackgroundCaptureMap(uint32_t sessionId) backgroundCaptureMap_.erase(sessionId); } } - + bool AudioService::NeedRemoveBackgroundCaptureMap(uint32_t sessionId, CapturerState capturerState) { SwitchState switchState; @@ -753,8 +753,13 @@ bool AudioService::CheckShouldCap(const AudioProcessConfig &rendererConfig, int3 } #endif -bool AudioService::ShouldBeDualTone(const AudioProcessConfig &config) +bool AudioService::ShouldBeDualTone(const AudioProcessConfig &config, const std::string &dupSinkName) { + // for dup device scene, use dmsdp speaker + if (dupSinkName != "Speaker") { + return true; + } + CHECK_AND_RETURN_RET_LOG(Util::IsRingerOrAlarmerStreamUsage(config.rendererInfo.streamUsage), false, "Wrong usage ,should not be dualtone"); AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); @@ -896,7 +901,7 @@ int32_t AudioService::EnableDualStream(const uint32_t sessionId, const std::stri AUDIO_WARNING_LOG("Renderer is already released!"); continue; } - if (ShouldBeDualTone(renderer->processConfig_)) { + if (ShouldBeDualTone(renderer->processConfig_, dupSinkName)) { renderer->EnableDualTone(dupSinkName); filteredDualToneRendererMap_.push_back(renderer); } diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index 337e5c7b63..bdf3dfef4f 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -511,13 +511,69 @@ HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_001, TestSize.Level1) AudioProcessConfig config = {}; config.audioMode = AUDIO_MODE_RECORD; config.rendererInfo.streamUsage = STREAM_USAGE_ALARM; - bool ret = AudioService::GetInstance()->ShouldBeDualTone(config); + bool ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); EXPECT_FALSE(ret); config.audioMode = AUDIO_MODE_PLAYBACK; - ret = AudioService::GetInstance()->ShouldBeDualTone(config); + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); EXPECT_FALSE(ret); } +/** + * @tc.name : Test ShouldBeDualTone API + * @tc.type : FUNC + * @tc.number: AudioServiceShouldBeDualTone_002 + * @tc.desc : Test ShouldBeDualTone interface. + */ +HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_002, TestSize.Level1) +{ + AudioProcessConfig config = {}; + config.audioMode = AUDIO_MODE_RECORD; + bool ret; + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); + EXPECT_EQ(ret, false); + config.audioMode = AUDIO_MODE_PLAYBACK; + config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE; + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test ShouldBeDualTone API + * @tc.type : FUNC + * @tc.number: AudioServiceShouldBeDualTone_003 + * @tc.desc : Test ShouldBeDualTone interface. + */ +HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_003, TestSize.Level1) +{ + AudioProcessConfig config = {}; + config.audioMode = AUDIO_MODE_PLAYBACK; + bool ret; + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); + EXPECT_EQ(ret, false); + config.audioMode = AUDIO_MODE_PLAYBACK; + config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE; + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test ShouldBeDualTone API + * @tc.type : FUNC + * @tc.number: AudioServiceShouldBeDualTone_004 + * @tc.desc : Test ShouldBeDualTone interface. + */ +HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_004, TestSize.Level1) +{ + AudioProcessConfig config = {}; + config.audioMode = AUDIO_MODE_PLAYBACK; + bool ret; + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker"); + EXPECT_EQ(ret, false); + + ret = AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker_Remote"); + EXPECT_EQ(ret, true); +} + /** * @tc.name : Test OnInitInnerCapList API * @tc.type : FUNC @@ -627,25 +683,6 @@ HWTEST(AudioServiceUnitTest, AudioServiceGetCapturerBySessionID_001, TestSize.Le EXPECT_EQ(nullptr, ret); } -/** - * @tc.name : Test ShouldBeDualTone API - * @tc.type : FUNC - * @tc.number: AudioServiceShouldBeDualTone_002 - * @tc.desc : Test ShouldBeDualTone interface. - */ -HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_002, TestSize.Level1) -{ - AudioProcessConfig config = {}; - config.audioMode = AUDIO_MODE_RECORD; - bool ret; - ret = AudioService::GetInstance()->ShouldBeDualTone(config); - EXPECT_EQ(ret, false); - config.audioMode = AUDIO_MODE_PLAYBACK; - config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE; - ret = AudioService::GetInstance()->ShouldBeDualTone(config); - EXPECT_FALSE(ret); -} - /** * @tc.name : Test FilterAllFastProcess API * @tc.type : FUNC @@ -1474,24 +1511,7 @@ HWTEST(AudioServiceUnitTest, UpdateAudioSinkState_002, TestSize.Level1) int32_t res = audioService->GetCurrentRendererStreamCnt(); EXPECT_EQ(res, 1); } -/** - * @tc.name : Test ShouldBeDualTone API - * @tc.type : FUNC - * @tc.number: AudioServiceShouldBeDualTone_003 - * @tc.desc : Test ShouldBeDualTone interface. - */ -HWTEST(AudioServiceUnitTest, AudioServiceShouldBeDualTone_003, TestSize.Level1) -{ - AudioProcessConfig config = {}; - config.audioMode = AUDIO_MODE_PLAYBACK; - bool ret; - ret = AudioService::GetInstance()->ShouldBeDualTone(config); - EXPECT_EQ(ret, false); - config.audioMode = AUDIO_MODE_PLAYBACK; - config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE; - ret = AudioService::GetInstance()->ShouldBeDualTone(config); - EXPECT_FALSE(ret); -} + /** * @tc.name : Test CheckHibernateState API * @tc.type : FUNC @@ -2921,11 +2941,11 @@ HWTEST(AudioServiceUnitTest, ShouldBeDualTone_001, TestSize.Level1) AudioProcessConfig config = {}; config.rendererInfo.streamUsage = STREAM_USAGE_MUSIC; - EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config)); + EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker")); config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE; AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); - EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config)); + EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker")); } /** @@ -2941,7 +2961,7 @@ HWTEST(AudioServiceUnitTest, ShouldBeDualTone_002, TestSize.Level1) config.audioMode = AUDIO_MODE_RECORD; AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); - EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config)); + EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker")); } /** @@ -2959,7 +2979,7 @@ HWTEST(AudioServiceUnitTest, ShouldBeDualTone_003, TestSize.Level1) AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); deviceInfo.deviceType_ = DEVICE_TYPE_WIRED_HEADSET; - EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config)); + EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker")); } /** @@ -2977,7 +2997,25 @@ HWTEST(AudioServiceUnitTest, ShouldBeDualTone_004, TestSize.Level1) AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); deviceInfo.deviceType_ = static_cast(999); // 未知设备类型 - EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config)); + EXPECT_FALSE(AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker")); +} + +/** + * @tc.name : Test ShouldBeDualTone API + * @tc.type : FUNC + * @tc.number: ShouldBeDualTone_005, + * @tc.desc : Test ShouldBeDualTone interface. + */ +HWTEST(AudioServiceUnitTest, ShouldBeDualTone_005, TestSize.Level1) +{ + AudioProcessConfig config = {}; + config.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE; + config.audioMode = AUDIO_MODE_PLAYBACK; + + AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); + deviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER; // 未知设备类型 + + EXPECT_TRUE(AudioService::GetInstance()->ShouldBeDualTone(config, "Speaker_remote")); } /** diff --git a/test/fuzztest/audioserviceserversrcenhance_fuzzer/audio_service_server_src_enhance_fuzzer.cpp b/test/fuzztest/audioserviceserversrcenhance_fuzzer/audio_service_server_src_enhance_fuzzer.cpp index 757087bb82..76173e8afd 100644 --- a/test/fuzztest/audioserviceserversrcenhance_fuzzer/audio_service_server_src_enhance_fuzzer.cpp +++ b/test/fuzztest/audioserviceserversrcenhance_fuzzer/audio_service_server_src_enhance_fuzzer.cpp @@ -116,7 +116,7 @@ void AudioServiceMoreFuzzTest() audioServicePtr->GetIpcStream(config, ret); #ifdef HAS_FEATURE_INNERCAPTURER audioServicePtr->ShouldBeInnerCap(config, 1); - audioServicePtr->ShouldBeDualTone(config); + audioServicePtr->ShouldBeDualTone(config, "Speaker"); audioServicePtr->OnInitInnerCapList(1); audioServicePtr->OnUpdateInnerCapList(1); -- Gitee