diff --git a/CODEOWNERS b/CODEOWNERS index a46e354811e7a12d884f3132309d77278511dd59..73b14c27cffb74e8e35d844c9c691b8a20473949 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-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 @@ -13,4 +13,5 @@ * limitations under the License. */ services/audio_policy/common/include/audio_policy_ipc_interface_code.h @leonchan5 - services/audio_service/client/include/pulseaudio_ipc_interface_code.h @leonchan5 \ No newline at end of file + services/audio_service/client/include/pulseaudio_ipc_interface_code.h @leonchan5 + services/audio_policy/server/infra/config/file/audio_interrupt_policy_config.xml @hao-liangfei @caihdl \ No newline at end of file diff --git a/bundle.json b/bundle.json index 5f07d12d3998a460ddb03d79a56f5cbf2128336e..7d5d2c256fa371c5c69c7bbe11fcdf7d2b91bef4 100644 --- a/bundle.json +++ b/bundle.json @@ -39,14 +39,13 @@ "audio_framework_feature_file_io", "audio_framework_feature_inner_capturer", "audio_framework_feature_low_latency", - "audio_framework_feature_new_engine_flag" + "audio_framework_feature_device_manager" ], "adapted_system_type": [ "standard" ], "rom": "4500KB", "ram": "11000KB", "deps": { "components": [ - "av_session", "ability_base", "ability_runtime", "access_token", @@ -98,8 +97,6 @@ "window_manager" ], "third_party": [ - "glib", - "libsnd", "libxml2", "openssl" ] diff --git a/cfi_blocklist.txt b/cfi_blocklist.txt index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..9e57ac2745e8bb36354e8ca99a7b96f3cde84c43 100644 --- a/cfi_blocklist.txt +++ b/cfi_blocklist.txt @@ -0,0 +1,3 @@ +src:*third_party/googletest/*:* +src:*foundation/multimedia/audio_framework/services/audio_policy/test/unittest/*:* +src:*foundation/multimedia/audio_framework/services/audio_policy/server/infra/config/parser/test/unittest/*:* \ No newline at end of file diff --git a/frameworks/cj/src/multimedia_audio_stream_manager_impl.cpp b/frameworks/cj/src/multimedia_audio_stream_manager_impl.cpp index 3765d1d964cdca674aa67c476e6864e1d041cf89..708a9f7eda4b3a5de0cd66850f8378c590069752 100644 --- a/frameworks/cj/src/multimedia_audio_stream_manager_impl.cpp +++ b/frameworks/cj/src/multimedia_audio_stream_manager_impl.cpp @@ -102,7 +102,7 @@ CArrAudioRendererChangeInfo MMAAudioStreamManagerImpl::GetCurrentRendererChangeI return CArrAudioRendererChangeInfo(); } arrInfo.head = head; - if (memset_s(head, arrInfo.size, 0, arrInfo.size) != EOK) { + if (memset_s(head, mallocSize, 0, mallocSize) != EOK) { free(head); *errorCode = CJ_ERR_SYSTEM; return CArrAudioRendererChangeInfo(); diff --git a/frameworks/js/napi/common/napi_audio_enum.cpp b/frameworks/js/napi/common/napi_audio_enum.cpp index c5fcfdf3fa84810b312c7297c6967923f68666c7..551e9941185cfd0ab708b88bf8e8a0e39e01caa4 100644 --- a/frameworks/js/napi/common/napi_audio_enum.cpp +++ b/frameworks/js/napi/common/napi_audio_enum.cpp @@ -547,6 +547,11 @@ const std::map NapiAudioEnum::outputDeviceChangeRecommende {"DEVICE_CHANGE_RECOMMEND_TO_STOP", static_cast(OutputDeviceChangeRecommendedAction::RECOMMEND_TO_STOP)}, }; +const std::map NapiAudioEnum::effectFlagMap = { + {"RENDER_EFFECT_FLAG", RENDER_EFFECT_FLAG}, + {"CAPTURE_EFFECT_FLAG", CAPTURE_EFFECT_FLAG}, +}; + NapiAudioEnum::NapiAudioEnum() : env_(nullptr) { } @@ -714,6 +719,7 @@ napi_status NapiAudioEnum::InitAudioEnum(napi_env env, napi_value exports) CreateEnumObject(env, audioSessionStateChangeHintMap)), DECLARE_NAPI_PROPERTY("OutputDeviceChangeRecommendedAction", CreateEnumObject(env, outputDeviceChangeRecommendedActionMap)), + DECLARE_NAPI_PROPERTY("EffectFlag", CreateEnumObject(env, effectFlagMap)), }; return napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop); } diff --git a/frameworks/js/napi/common/napi_audio_enum.h b/frameworks/js/napi/common/napi_audio_enum.h index c18a11233cdc3d06d526186f8d10b87879a48455..3d44de7041b1f655ebde2a465168d86b4a9b9497 100644 --- a/frameworks/js/napi/common/napi_audio_enum.h +++ b/frameworks/js/napi/common/napi_audio_enum.h @@ -304,6 +304,7 @@ private: static const std::map audioSessionSceneMap; static const std::map audioSessionStateChangeHintMap; static const std::map outputDeviceChangeRecommendedActionMap; + static const std::map effectFlagMap; static std::unique_ptr sAudioParameters_; std::unique_ptr audioParameters_; diff --git a/frameworks/native/audiocapturer/include/audio_capturer_private.h b/frameworks/native/audiocapturer/include/audio_capturer_private.h index d62592990d1218435f275c2c3b72d1e4576aa37f..8fb3aac934279f08880eaf6325f30a9203691ede 100644 --- a/frameworks/native/audiocapturer/include/audio_capturer_private.h +++ b/frameworks/native/audiocapturer/include/audio_capturer_private.h @@ -142,7 +142,6 @@ private: int32_t InitInputDeviceChangeCallback(); int32_t SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr audioStream); void InitSwitchInfo(IAudioStream::StreamClass targetClass, IAudioStream::SwitchInfo &info); - bool ContinueAfterConcede(IAudioStream::StreamClass &targetClass, RestoreInfo restoreInfo); bool ContinueAfterSplit(RestoreInfo restoreInfo); bool SwitchToTargetStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo); bool FinishOldStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo, CapturerState previousState, diff --git a/frameworks/native/audiocapturer/src/audio_capturer.cpp b/frameworks/native/audiocapturer/src/audio_capturer.cpp index 53e285d8ac1baa5a11c28bf1df1315d61d2494bc..6e9357c0aa5c238d500cc4ed2489745ce504a875 100644 --- a/frameworks/native/audiocapturer/src/audio_capturer.cpp +++ b/frameworks/native/audiocapturer/src/audio_capturer.cpp @@ -1575,25 +1575,6 @@ bool AudioCapturerPrivate::GenerateNewStream(IAudioStream::StreamClass targetCla return true; } -bool AudioCapturerPrivate::ContinueAfterConcede(IAudioStream::StreamClass &targetClass, RestoreInfo restoreInfo) -{ - CHECK_AND_RETURN_RET(restoreInfo.restoreReason == STREAM_CONCEDED, true); - targetClass = IAudioStream::PA_STREAM; - if (audioStream_->GetStreamClass() == IAudioStream::PA_STREAM) { - AUDIO_WARNING_LOG("Already pa stream, no need for concede"); - audioStream_->SetRestoreStatus(NO_NEED_FOR_RESTORE); - return false; - } - AudioPipeType pipeType = PIPE_TYPE_NORMAL_IN; - audioStream_->GetAudioPipeType(pipeType); - AUDIO_INFO_LOG("session %{public}u concede from pipeType %{public}d", sessionID_, capturerInfo_.pipeType); - if (pipeType == PIPE_TYPE_LOWLATENCY_IN || pipeType == PIPE_TYPE_CALL_IN) { - return true; - } - audioStream_->SetRestoreStatus(NO_NEED_FOR_RESTORE); - return false; -} - bool AudioCapturerPrivate::ContinueAfterSplit(RestoreInfo restoreInfo) { CHECK_AND_RETURN_RET(restoreInfo.restoreReason == STREAM_SPLIT, true); @@ -1614,8 +1595,6 @@ bool AudioCapturerPrivate::SwitchToTargetStream(IAudioStream::StreamClass target restoreInfo.restoreReason, restoreInfo.deviceChangeReason, restoreInfo.targetStreamFlag); // Check if continue to switch after some concede operation. - CHECK_AND_RETURN_RET_LOG(ContinueAfterConcede(targetClass, restoreInfo), - true, "No need for switch"); CHECK_AND_RETURN_RET(ContinueAfterSplit(restoreInfo), true, "Stream split"); isSwitching_ = true; diff --git a/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_plus_unit_test.cpp b/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_plus_unit_test.cpp index 8105d0c03bb6d2311a3825b29963b27dd430b25b..19bbdd4c2bae5e0e3bf39b488f7d7650e5cc9fd9 100644 --- a/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_plus_unit_test.cpp +++ b/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_plus_unit_test.cpp @@ -443,98 +443,6 @@ HWTEST(AudioCapturerUnitTest, AudioCapturerPrivate_009, TestSize.Level1) EXPECT_EQ(ret, SUCCESS); } -/** - * @tc.name : Test AudioCapturerPrivate API - * @tc.type : FUNC - * @tc.number: AudioCapturerPrivate_010 - * @tc.desc : Test AudioCapturerPrivate::ContinueAfterConcede - */ -HWTEST(AudioCapturerUnitTest, AudioCapturerPrivate_010, TestSize.Level1) -{ - AppInfo appInfo = {}; - auto capturer = std::make_shared(AudioStreamType::STREAM_VOICE_CALL, appInfo, true); - ASSERT_NE(capturer, nullptr); - - capturer->audioStream_ = std::make_shared(); - ASSERT_NE(capturer->audioStream_, nullptr); - - IAudioStream::StreamClass targetClass; - RestoreInfo restoreInfo; - restoreInfo.restoreReason = STREAM_CONCEDED; - - auto ret = capturer->ContinueAfterConcede(targetClass, restoreInfo); - EXPECT_EQ(ret, false); -} - -/** - * @tc.name : Test AudioCapturerPrivate API - * @tc.type : FUNC - * @tc.number: AudioCapturerPrivate_011 - * @tc.desc : Test AudioCapturerPrivate::ContinueAfterConcede - */ -HWTEST(AudioCapturerUnitTest, AudioCapturerPrivate_011, TestSize.Level1) -{ - AppInfo appInfo = {}; - auto capturer = std::make_shared(AudioStreamType::STREAM_VOICE_CALL, appInfo, true); - ASSERT_NE(capturer, nullptr); - - capturer->audioStream_ = std::make_shared(); - ASSERT_NE(capturer->audioStream_, nullptr); - - IAudioStream::StreamClass targetClass; - RestoreInfo restoreInfo; - restoreInfo.restoreReason = STREAM_CONCEDED; - - auto ret = capturer->ContinueAfterConcede(targetClass, restoreInfo); - EXPECT_EQ(ret, true); -} - -/** - * @tc.name : Test AudioCapturerPrivate API - * @tc.type : FUNC - * @tc.number: AudioCapturerPrivate_012 - * @tc.desc : Test AudioCapturerPrivate::ContinueAfterConcede - */ -HWTEST(AudioCapturerUnitTest, AudioCapturerPrivate_012, TestSize.Level1) -{ - AppInfo appInfo = {}; - auto capturer = std::make_shared(AudioStreamType::STREAM_VOICE_CALL, appInfo, true); - ASSERT_NE(capturer, nullptr); - - capturer->audioStream_ = std::make_shared(); - ASSERT_NE(capturer->audioStream_, nullptr); - - IAudioStream::StreamClass targetClass; - RestoreInfo restoreInfo; - restoreInfo.restoreReason = STREAM_CONCEDED; - - auto ret = capturer->ContinueAfterConcede(targetClass, restoreInfo); - EXPECT_EQ(ret, true); -} - -/** - * @tc.name : Test AudioCapturerPrivate API - * @tc.type : FUNC - * @tc.number: AudioCapturerPrivate_013 - * @tc.desc : Test AudioCapturerPrivate::ContinueAfterConcede - */ -HWTEST(AudioCapturerUnitTest, AudioCapturerPrivate_013, TestSize.Level1) -{ - AppInfo appInfo = {}; - auto capturer = std::make_shared(AudioStreamType::STREAM_VOICE_CALL, appInfo, true); - ASSERT_NE(capturer, nullptr); - - capturer->audioStream_ = std::make_shared(); - ASSERT_NE(capturer->audioStream_, nullptr); - - IAudioStream::StreamClass targetClass; - RestoreInfo restoreInfo; - restoreInfo.restoreReason = STREAM_CONCEDED; - - auto ret = capturer->ContinueAfterConcede(targetClass, restoreInfo); - EXPECT_EQ(ret, false); -} - /** * @tc.name : Test AudioCapturerPrivate API * @tc.type : FUNC diff --git a/frameworks/native/audiodefinitions/BUILD.gn b/frameworks/native/audiodefinitions/BUILD.gn index 6b6b2eba054b8cf3731e04702b495bab2407ae27..721c4cce99f1677a55aab806a85cc1983bcc7e7f 100644 --- a/frameworks/native/audiodefinitions/BUILD.gn +++ b/frameworks/native/audiodefinitions/BUILD.gn @@ -80,14 +80,16 @@ ohos_unittest("audio_definitions_unit_test") { ] include_dirs = [ - "./include", + "./test/unittest", "../../../frameworks/native/audioutils/include", "../../../interfaces/inner_api/native/audiocommon/include", "../../../services/audio_policy/common/include", ] sources = [ + "test/unittest/audio_definitions_unit_test_utils.cpp", "test/unittest/audio_stream_descriptor_unit_test.cpp", + "test/unittest/audio_pipe_info_unit_test.cpp", ] deps = [ diff --git a/frameworks/native/audiodefinitions/include/audio_pipe_info.h b/frameworks/native/audiodefinitions/include/audio_pipe_info.h index e343f67dd4b4abdb9d6011f4de2b61e4ee9bed40..3472c14d75b308819ed8859c15f69b9198995724 100644 --- a/frameworks/native/audiodefinitions/include/audio_pipe_info.h +++ b/frameworks/native/audiodefinitions/include/audio_pipe_info.h @@ -47,8 +47,8 @@ public: std::string adapterName_ = ""; AudioModuleInfo moduleInfo_ = {}; + AudioStreamInfo audioStreamInfo_ = {}; - void InitAudioStreamInfo(); AudioPipeAction pipeAction_ = PIPE_ACTION_DEFAULT; @@ -64,16 +64,65 @@ public: AudioPipeInfo(const std::shared_ptr pipeInfo); - void Dump(std::string &dumpString); - - std::string ToString(); + uint32_t GetId() const + { + return id_; + } -private: - bool IsOutput() + bool IsOutput() const { return pipeRole_ == PIPE_ROLE_OUTPUT; } + std::string GetName() const + { + return name_; + } + + std::string GetAdapterName() const + { + return adapterName_; + } + + AudioPipeAction GetAction() const + { + return pipeAction_; + } + + uint32_t GetRoute() const + { + return routeFlag_; + } + + bool IsRouteNormal() const + { + return IsOutput() ? + (routeFlag_ == AUDIO_OUTPUT_FLAG_NORMAL) : (routeFlag_ == AUDIO_INPUT_FLAG_NORMAL); + } + + bool IsSameAdapter(const std::string &targetAdapterName) const + { + return adapterName_ == targetAdapterName; + } + + void SetAction(AudioPipeAction action) + { + pipeAction_ = action; + } + + void Dump(std::string &dumpString); + + std::string ToString(); + + bool ContainStream(uint32_t sessionId) const; + + void AddStream(std::shared_ptr stream); + + void RemoveStream(uint32_t sessionId); + + void InitAudioStreamInfo(); + +private: void DumpCommonAttrs(std::string &dumpString); void DumpOutputAttrs(std::string &dumpString); diff --git a/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h b/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h index c241bf23ae0e50c5430ffe0e7f0df754e4db7ef2..80dba1c41ba5d0f780ef04f0685a9264645150ad 100644 --- a/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h +++ b/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h @@ -17,6 +17,7 @@ #define AUDIO_STREAM_DESCRIPTOR_H #include +#include #include "parcel.h" #include "audio_device_descriptor.h" #include "audio_stream_enum.h" @@ -37,6 +38,7 @@ public: AudioMode audioMode_ = AUDIO_MODE_PLAYBACK; AudioFlag audioFlag_ = AUDIO_FLAG_NONE; uint32_t routeFlag_ = AUDIO_FLAG_NONE; + uint32_t oldRouteFlag_ = AUDIO_FLAG_NONE; int64_t createTimeStamp_ = 0; int64_t startTimeStamp_ = 0; AudioRendererInfo rendererInfo_ = {}; @@ -51,16 +53,16 @@ public: mutable std::vector> newDeviceDescs_ = {}; std::string bundleName_ = ""; - AudioStreamDescriptor(); - virtual ~AudioStreamDescriptor(); + AudioStreamDescriptor() = default; + AudioStreamDescriptor(AudioStreamInfo streamInfo, AudioRendererInfo rendererInfo, AppInfo appInfo); + AudioStreamDescriptor(AudioStreamInfo streamInfo, AudioCapturerInfo rendererInfo, AppInfo appInfo); + virtual ~AudioStreamDescriptor() = default; + + // Need to delete later + void CopyToStruct(AudioStreamDescriptor &streamDesc); bool Marshalling(Parcel &parcel) const override; static AudioStreamDescriptor *Unmarshalling(Parcel &parcel); - bool WriteDeviceDescVectorToParcel( - Parcel &parcel, std::vector> &descs) const; - void UnmarshallingDeviceDescVector(Parcel &parcel, std::vector> &descs); - - void SetBunduleName(std::string &bundleName); // log and dump void Dump(std::string &dumpString); @@ -68,15 +70,164 @@ public: std::string GetNewDevicesInfo(); std::string GetDeviceInfo(std::shared_ptr desc); -private: - bool IsRenderer() + // Common info funcs above + bool IsPlayback() const + { + return (audioMode_ == AUDIO_MODE_PLAYBACK); + } + + bool IsRecording() const + { + return (audioMode_ == AUDIO_MODE_RECORD); + } + + uint32_t GetSessionId() const + { + return sessionId_; + } + + bool IsRunning() const + { + return (streamStatus_ == STREAM_STATUS_STARTED); + } + + void SetStatus(AudioStreamStatus status) + { + streamStatus_ = status; + } + + void SetAction(AudioStreamAction action) + { + streamAction_ = action; + } + + void SetBunduleName(std::string &bundleName); + + std::string GetBundleName() + { + return bundleName_; + } + + AudioStreamAction GetAction() const + { + return streamAction_; + } + + AudioFlag GetAudioFlag() const + { + return audioFlag_; + } + + void SetAudioFlag(AudioFlag flag) + { + audioFlag_ = flag; + } + + bool IsUseMoveToConcedeType() const + { + return (audioFlag_ == AUDIO_OUTPUT_FLAG_LOWPOWER) || + (audioFlag_ == AUDIO_OUTPUT_FLAG_MULTICHANNEL); + } + + // Route funcs above + uint32_t GetRoute() const { - return audioMode_ == AUDIO_MODE_PLAYBACK; + return routeFlag_; } + + void SetRoute(uint32_t flag) + { + routeFlag_ = flag; + } + + void SetOldRoute(uint32_t route) + { + oldRouteFlag_ = route; + } + + uint32_t GetOldRoute() const + { + return oldRouteFlag_; + } + + bool IsRouteNormal() const + { + if (IsPlayback()) { + return (routeFlag_ == AUDIO_OUTPUT_FLAG_NORMAL); + } else { + return (routeFlag_ == AUDIO_INPUT_FLAG_NORMAL); + } + } + + bool IsRouteOffload() const + { + return (routeFlag_ & AUDIO_OUTPUT_FLAG_LOWPOWER); + } + + bool IsNoRunningOffload() const + { + return IsRouteOffload() && !IsRunning(); + } + + void ResetToNormalRoute(bool updateRoute); + + bool IsOldRouteOffload() const + { + return (oldRouteFlag_ & AUDIO_OUTPUT_FLAG_LOWPOWER); + } + + // Device funcs above + DeviceType GetMainNewDeviceType() + { + std::lock_guard lock(lock_); + if (newDeviceDescs_.size() < 1 || newDeviceDescs_[0] == nullptr) { + return DEVICE_TYPE_NONE; + } + return newDeviceDescs_[0]->getType(); + } + + void AddNewDevice(std::shared_ptr device) + { + if (device == nullptr) { + return; + } + std::lock_guard lock(lock_); + newDeviceDescs_.push_back(device); + } + + void UpdateNewDevice(std::vector> devices) + { + std::lock_guard lock(lock_); + for (auto &device : devices) { + if (device == nullptr) { + return; + } + } + newDeviceDescs_ = devices; + } + + bool IsDeviceRemote() + { + std::lock_guard lock(lock_); + for (auto &device : newDeviceDescs_) { + if (device != nullptr && device->IsRemote()) { + return true; + } + } + return false; + } + +private: + bool WriteDeviceDescVectorToParcel( + Parcel &parcel, std::vector> &descs) const; + void UnmarshallingDeviceDescVector(Parcel &parcel, std::vector> &descs); + void DumpCommonAttrs(std::string &dumpString); void DumpRendererStreamAttrs(std::string &dumpString); void DumpCapturerStreamAttrs(std::string &dumpString); void DumpDeviceAttrs(std::string &dumpString); + + std::mutex lock_; }; } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/native/audiodefinitions/include/audio_stream_enum.h b/frameworks/native/audiodefinitions/include/audio_stream_enum.h index d848812e22d74bd63d2ef0b2221af0ffb8e806e4..cddc7c5e8e3fea63e0ae29d626e97b55cd6fc4c0 100644 --- a/frameworks/native/audiodefinitions/include/audio_stream_enum.h +++ b/frameworks/native/audiodefinitions/include/audio_stream_enum.h @@ -41,6 +41,7 @@ enum AudioFlag : uint32_t { AUDIO_INPUT_FLAG_VOIP = 0x4000, // select AUDIO_INPUT_FLAG_VOIP_FAST = 0x8000, // select, route AUDIO_INPUT_FLAG_WAKEUP = 0x10000, // select, route + AUDIO_INPUT_FLAG_AI = 0x20000, // select, route AUDIO_FLAG_MAX, }; diff --git a/frameworks/native/audiodefinitions/src/audio_pipe_info.cpp b/frameworks/native/audiodefinitions/src/audio_pipe_info.cpp index ce820d94119d05cc30aebb5cf404607e12ef58bb..fcdea6467c0ced50899e555c24906e26a777a2a4 100644 --- a/frameworks/native/audiodefinitions/src/audio_pipe_info.cpp +++ b/frameworks/native/audiodefinitions/src/audio_pipe_info.cpp @@ -127,5 +127,31 @@ std::string AudioPipeInfo::ToString() return out; } +bool AudioPipeInfo::ContainStream(uint32_t sessionId) const +{ + return (streamDescMap_.find(sessionId) != streamDescMap_.end()); +} + +void AudioPipeInfo::AddStream(std::shared_ptr stream) +{ + streamDescriptors_.push_back(stream); + streamDescMap_[stream->GetSessionId()] = stream; +} + +void AudioPipeInfo::RemoveStream(uint32_t sessionId) +{ + if (!ContainStream(sessionId)) { + return; + } + + // Both streamdesc data need remove + streamDescMap_.erase(sessionId); + streamDescriptors_.erase(std::remove_if(streamDescriptors_.begin(), streamDescriptors_.end(), + [&sessionId] (const std::shared_ptr &stream) { + return stream->GetSessionId() == sessionId; + }), + streamDescriptors_.end()); +} + } // AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp b/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp index 866df4247db1fbd8e4e1fb5b0117f583e7902389..cdb2fd67123a83cf41e7cca4dd184f3bb72225f4 100644 --- a/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp +++ b/frameworks/native/audiodefinitions/src/audio_stream_descriptor.cpp @@ -41,20 +41,53 @@ static const char *StreamStatusToString(AudioStreamStatus status) } } -AudioStreamDescriptor::AudioStreamDescriptor() +AudioStreamDescriptor::AudioStreamDescriptor( + AudioStreamInfo streamInfo, AudioRendererInfo rendererInfo, AppInfo appInfo) + : streamInfo_(streamInfo), + audioMode_(AUDIO_MODE_PLAYBACK), + rendererInfo_(rendererInfo), + appInfo_(appInfo) { } -AudioStreamDescriptor::~AudioStreamDescriptor() +AudioStreamDescriptor::AudioStreamDescriptor( + AudioStreamInfo streamInfo, AudioCapturerInfo capturerInfo, AppInfo appInfo) + : streamInfo_(streamInfo), + audioMode_(AUDIO_MODE_RECORD), + capturerInfo_(capturerInfo), + appInfo_(appInfo) { } +void AudioStreamDescriptor::CopyToStruct(AudioStreamDescriptor &streamDesc) +{ + streamDesc.streamInfo_ = streamInfo_; + streamDesc.audioMode_ = audioMode_; + streamDesc.audioFlag_ = audioFlag_; + streamDesc.routeFlag_ = routeFlag_; + streamDesc.oldRouteFlag_ = oldRouteFlag_; + streamDesc.createTimeStamp_ = createTimeStamp_; + streamDesc.startTimeStamp_ = startTimeStamp_; + streamDesc.rendererInfo_ = rendererInfo_; + streamDesc.capturerInfo_ = capturerInfo_; + streamDesc.appInfo_ = appInfo_; + streamDesc.sessionId_ = sessionId_; + streamDesc.callerUid_ = callerUid_; + streamDesc.callerPid_ = callerPid_; + streamDesc.streamStatus_ = streamStatus_; + streamDesc.streamAction_ = streamAction_; + streamDesc.oldDeviceDescs_ = oldDeviceDescs_; + streamDesc.newDeviceDescs_ = newDeviceDescs_; + streamDesc.bundleName_ = bundleName_; +} + bool AudioStreamDescriptor::Marshalling(Parcel &parcel) const { return streamInfo_.Marshalling(parcel) && parcel.WriteUint32(audioMode_) && parcel.WriteUint32(audioFlag_) && parcel.WriteUint32(routeFlag_) && + parcel.WriteUint32(oldRouteFlag_) && parcel.WriteInt64(createTimeStamp_) && parcel.WriteInt64(startTimeStamp_) && rendererInfo_.Marshalling(parcel) && @@ -82,6 +115,7 @@ AudioStreamDescriptor *AudioStreamDescriptor::Unmarshalling(Parcel &parcel) info->audioMode_ = static_cast(parcel.ReadUint32()); info->audioFlag_ = static_cast(parcel.ReadUint32()); info->routeFlag_ = static_cast(parcel.ReadUint32()); + info->oldRouteFlag_ = static_cast(parcel.ReadUint32()); info->createTimeStamp_ = parcel.ReadInt64(); info->startTimeStamp_ = parcel.ReadInt64(); info->rendererInfo_.UnmarshallingSelf(parcel); @@ -120,8 +154,7 @@ bool AudioStreamDescriptor::WriteDeviceDescVectorToParcel( void AudioStreamDescriptor::UnmarshallingDeviceDescVector( Parcel &parcel, std::vector> &descs) { - int32_t size = 0; - parcel.ReadInt32(size); + int32_t size = parcel.ReadInt32(); if (size == -1 || size > MAX_STREAM_DESCRIPTORS_SIZE) { AUDIO_ERR_LOG("Invalid vector size"); return; @@ -139,7 +172,7 @@ void AudioStreamDescriptor::SetBunduleName(std::string &bundleName) void AudioStreamDescriptor::Dump(std::string &dumpString) { - AppendFormat(dumpString, " Stream %d:\n", sessionId_); + AppendFormat(dumpString, " Stream %u:\n", sessionId_); DumpCommonAttrs(dumpString); @@ -165,7 +198,8 @@ void AudioStreamDescriptor::DumpCommonAttrs(std::string &dumpString) streamInfo_.samplingRate, streamInfo_.channels, streamInfo_.channelLayout, streamInfo_.format, streamInfo_.encoding); - AppendFormat(dumpString, " - AudioFlag: 0x%x RouteFlag: 0x%x\n", audioFlag_, routeFlag_); + AppendFormat(dumpString, " - AudioFlag: 0x%x RouteFlag: 0x%x OldRouteFlag: 0x%x\n", + audioFlag_, routeFlag_, oldRouteFlag_); AppendFormat(dumpString, " - CreateTimestamp: %" PRId64"\n", createTimeStamp_); AppendFormat(dumpString, " - StartTimestamp: %" PRId64"\n", startTimeStamp_); } @@ -233,5 +267,14 @@ std::string AudioStreamDescriptor::GetNewDevicesInfo() } return out; } + +void AudioStreamDescriptor::ResetToNormalRoute(bool updateRoute) +{ + if (updateRoute) { + oldRouteFlag_ = routeFlag_; + } + routeFlag_ = (IsPlayback() ? AUDIO_OUTPUT_FLAG_NORMAL : AUDIO_INPUT_FLAG_NORMAL); +} + } // AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/audiodefinitions/test/unittest/audio_definitions_unit_test_utils.cpp b/frameworks/native/audiodefinitions/test/unittest/audio_definitions_unit_test_utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..afcc0f357dc08e7bf5ab0af0c6f0a71333e5cf64 --- /dev/null +++ b/frameworks/native/audiodefinitions/test/unittest/audio_definitions_unit_test_utils.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_definitions_unit_test_utils.h" + +namespace OHOS { +namespace AudioStandard { + +std::shared_ptr AudioDefinitionsUnitTestUtil::GenerateCommonStream(AudioMode mode) +{ + AudioStreamInfo streamInfo = { + TEST_AUDIO_SAMPLE_RATE, + TEST_AUDIO_ENCODING_TYPE, + TEST_AUDIO_SAMPLE_FORMAT, + TEST_AUDIO_CHANNEL, + TEST_AUDIO_CHANNEL_LAYOUT + }; + + AppInfo appInfo = { + TEST_UID, + TEST_TOKEN_ID, + TEST_PID, + TEST_FULL_TOKEN_ID + }; + + std::shared_ptr streamDesc; + if (mode == AUDIO_MODE_PLAYBACK) { + AudioRendererInfo rendererInfo(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE); + streamDesc = std::make_shared( + streamInfo, rendererInfo, appInfo); + streamDesc->sessionId_ = TEST_RENDERER_SESSION_ID; + } else { + AudioCapturerInfo capturerInfo(SOURCE_TYPE_MIC, 0); + streamDesc = std::make_shared( + streamInfo, capturerInfo, appInfo); + streamDesc->sessionId_ = TEST_CAPTURER_SESSION_ID; + } + + return streamDesc; +} + +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/audiodefinitions/test/unittest/audio_definitions_unit_test_utils.h b/frameworks/native/audiodefinitions/test/unittest/audio_definitions_unit_test_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..8dc522df14459e7612df35980e47f154e94fcfdd --- /dev/null +++ b/frameworks/native/audiodefinitions/test/unittest/audio_definitions_unit_test_utils.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_DEFINITIONS_UNIT_TEST_UTILS_H +#define AUDIO_DEFINITIONS_UNIT_TEST_UTILS_H + +#include "audio_stream_descriptor.h" + +namespace OHOS { +namespace AudioStandard { + +const uint32_t TEST_RENDERER_SESSION_ID = 100000; +const uint32_t TEST_CAPTURER_SESSION_ID = 100001; +const AudioSamplingRate TEST_AUDIO_SAMPLE_RATE = SAMPLE_RATE_48000; +const AudioEncodingType TEST_AUDIO_ENCODING_TYPE = ENCODING_PCM; +const AudioSampleFormat TEST_AUDIO_SAMPLE_FORMAT = SAMPLE_S16LE; +const AudioChannel TEST_AUDIO_CHANNEL = STEREO; +const AudioChannelLayout TEST_AUDIO_CHANNEL_LAYOUT = CH_LAYOUT_STEREO; +const int32_t TEST_UID = 1000; +const uint32_t TEST_TOKEN_ID = 10000; +const int32_t TEST_PID = 2000; +const uint64_t TEST_FULL_TOKEN_ID = 20000; + +class AudioDefinitionsUnitTestUtil { +public: + static std::shared_ptr GenerateCommonStream(AudioMode mode); +}; + +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_DEFINITIONS_UNIT_TEST_UTILS_H diff --git a/frameworks/native/audiodefinitions/test/unittest/audio_pipe_info_unit_test.cpp b/frameworks/native/audiodefinitions/test/unittest/audio_pipe_info_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0ac64b3aeb5ad3956f4ed463d469d7691081c0ae --- /dev/null +++ b/frameworks/native/audiodefinitions/test/unittest/audio_pipe_info_unit_test.cpp @@ -0,0 +1,223 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_pipe_info.h" + +#include + +#include + +#include "audio_common_log.h" +#include "audio_definitions_unit_test_utils.h" + +using namespace testing::ext; +using namespace std; + +namespace OHOS { +namespace AudioStandard { + +static const uint32_t TEST_OUTPUT_PIPE_ID = 0; +static const std::string TEST_OUTPUT_PIPE_NAME = "primary_output"; +static const uint32_t TEST_OUTPUT_PIPE_ROUTE = AUDIO_OUTPUT_FLAG_NORMAL; +static const std::string TEST_OUTPUT_PIPE_ADAPTER = "primary"; +static const uint32_t TEST_INPUT_PIPE_ID = 4096; +static const std::string TEST_INPUT_PIPE_NAME = "primary_input"; +static const uint32_t TEST_INPUT_PIPE_ROUTE = AUDIO_INPUT_FLAG_NORMAL; +static const std::string TEST_INPUT_PIPE_ADAPTER = "primary"; + +class AudioPipeInfoUnitTest : public ::testing::Test { +public: + static void SetUpTestCase(){}; + static void TearDownTestCase(){}; + virtual void SetUp(); + virtual void TearDown(); + +private: + std::shared_ptr testOutputPipe_ = nullptr; + std::shared_ptr testInputPipe_ = nullptr; +}; + +void AudioPipeInfoUnitTest::SetUp() +{ + testOutputPipe_ = std::make_shared(); + // Replace by constructor or builder in future + testOutputPipe_->id_ = TEST_OUTPUT_PIPE_ID; + testOutputPipe_->pipeRole_ = PIPE_ROLE_OUTPUT; + testOutputPipe_->name_ = TEST_OUTPUT_PIPE_NAME; + testOutputPipe_->routeFlag_ = TEST_OUTPUT_PIPE_ROUTE; + testOutputPipe_->adapterName_ = TEST_OUTPUT_PIPE_ADAPTER; + + testInputPipe_ = std::make_shared(); + // Replace by constructor or builder in future + testInputPipe_->id_ = TEST_INPUT_PIPE_ID; + testInputPipe_->pipeRole_ = PIPE_ROLE_INPUT; + testInputPipe_->name_ = TEST_INPUT_PIPE_NAME; + testInputPipe_->routeFlag_ = TEST_INPUT_PIPE_ROUTE; + testInputPipe_->adapterName_ = TEST_INPUT_PIPE_ADAPTER; +} + +void AudioPipeInfoUnitTest::TearDown() +{ + testOutputPipe_ = nullptr; + testInputPipe_ = nullptr; +} + +/** + * @tc.name : AudioPipeInfo_AllSimpleGet_001 + * @tc.number : AllSimpleGet_001 + * @tc.desc : Test all simple Get() funcs by default output pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, AllSimpleGet_001, TestSize.Level2) +{ + EXPECT_EQ(TEST_OUTPUT_PIPE_ID, testOutputPipe_->GetId()); + + EXPECT_EQ(true, testOutputPipe_->IsOutput()); + + EXPECT_EQ(TEST_OUTPUT_PIPE_NAME, testOutputPipe_->GetName()); + + EXPECT_EQ(TEST_OUTPUT_PIPE_ADAPTER, testOutputPipe_->GetAdapterName()); + + EXPECT_EQ(PIPE_ACTION_DEFAULT, testOutputPipe_->GetAction()); + + EXPECT_EQ(TEST_OUTPUT_PIPE_ROUTE, testOutputPipe_->GetRoute()); +} + +/** + * @tc.name : AudioPipeInfo_AllSimpleSet_001 + * @tc.number : AllSimpleSet_001 + * @tc.desc : Test all simple Set() funcs by default output pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, AllSimpleSet_001, TestSize.Level2) +{ + testOutputPipe_->SetAction(PIPE_ACTION_UPDATE); + EXPECT_EQ(PIPE_ACTION_UPDATE, testOutputPipe_->GetAction()); +} + +/** + * @tc.name : AudioPipeInfo_AllOutputRoute_001 + * @tc.number : AllOutputRoute_001 + * @tc.desc : Test all simple route funcs by default output pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, AllOutputRoute_001, TestSize.Level2) +{ + testOutputPipe_->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL; + EXPECT_EQ(true, testOutputPipe_->IsRouteNormal()); + + testOutputPipe_->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST; + EXPECT_EQ(false, testOutputPipe_->IsRouteNormal()); +} + +/** + * @tc.name : AudioPipeInfo_AllInputRoute_001 + * @tc.number : AllInputRoute_001 + * @tc.desc : Test all simple route funcs by default input pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, AllInputRoute_001, TestSize.Level2) +{ + testInputPipe_->routeFlag_ = AUDIO_INPUT_FLAG_NORMAL; + EXPECT_EQ(true, testInputPipe_->IsRouteNormal()); + + testInputPipe_->routeFlag_ = AUDIO_INPUT_FLAG_FAST; + EXPECT_EQ(false, testInputPipe_->IsRouteNormal()); +} + +/** + * @tc.name : AudioPipeInfo_AllSimpleAdapter_001 + * @tc.number : AllSimpleAdapter_001 + * @tc.desc : Test all simple adapter funcs by default input pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, AllSimpleAdapter_001, TestSize.Level2) +{ + EXPECT_EQ(true, testOutputPipe_->IsSameAdapter(TEST_OUTPUT_PIPE_ADAPTER)); + + EXPECT_EQ(false, testOutputPipe_->IsSameAdapter("")); +} + +/** + * @tc.name : AudioPipeInfo_Dump_001 + * @tc.number : Dump_001 + * @tc.desc : Test dump funcs by default output pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, Dump_001, TestSize.Level3) +{ + std::string dumpStr; + testOutputPipe_->Dump(dumpStr); + EXPECT_NE("", dumpStr); + + dumpStr = ""; + auto stream = AudioDefinitionsUnitTestUtil::GenerateCommonStream(AUDIO_MODE_PLAYBACK); + testOutputPipe_->AddStream(stream); + testOutputPipe_->Dump(dumpStr); + EXPECT_NE("", dumpStr); +} + +/** + * @tc.name : AudioPipeInfo_Dump_002 + * @tc.number : Dump_002 + * @tc.desc : Test dump funcs by default input pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, Dump_002, TestSize.Level3) +{ + std::string dumpStr; + testInputPipe_->Dump(dumpStr); + EXPECT_NE("", dumpStr); + + dumpStr = ""; + auto stream = AudioDefinitionsUnitTestUtil::GenerateCommonStream(AUDIO_MODE_RECORD); + testInputPipe_->AddStream(stream); + testInputPipe_->Dump(dumpStr); + EXPECT_NE("", dumpStr); +} + +/** + * @tc.name : AudioPipeInfo_ToString_001 + * @tc.number : ToString_001 + * @tc.desc : Test ToString() by default output pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, ToString_001, TestSize.Level3) +{ + std::string out = testOutputPipe_->ToString(); + EXPECT_NE("", out); +} + +/** + * @tc.name : AudioPipeInfo_StreamOperation_001 + * @tc.number : StreamOperation_001 + * @tc.desc : Test stream operation funcs by default output pipe + */ +HWTEST_F(AudioPipeInfoUnitTest, StreamOperation_001, TestSize.Level2) +{ + auto stream = AudioDefinitionsUnitTestUtil::GenerateCommonStream(AUDIO_MODE_PLAYBACK); + testOutputPipe_->AddStream(stream); + EXPECT_EQ(true, testOutputPipe_->ContainStream(stream->GetSessionId())); + + testOutputPipe_->RemoveStream(stream->GetSessionId()); + EXPECT_EQ(false, testOutputPipe_->ContainStream(stream->GetSessionId())); +} + +/** + * @tc.name : AudioPipeInfo_StreamOperation_002 + * @tc.number : StreamOperation_002 + * @tc.desc : Test stream operation funcs by default output pipe in abnormal situations + */ +HWTEST_F(AudioPipeInfoUnitTest, StreamOperation_002, TestSize.Level4) +{ + auto stream = AudioDefinitionsUnitTestUtil::GenerateCommonStream(AUDIO_MODE_PLAYBACK); + testOutputPipe_->RemoveStream(stream->GetSessionId()); + EXPECT_EQ(false, testOutputPipe_->ContainStream(stream->GetSessionId())); +} + +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/audiodefinitions/test/unittest/audio_stream_descriptor_unit_test.cpp b/frameworks/native/audiodefinitions/test/unittest/audio_stream_descriptor_unit_test.cpp index 11bfabb80fcd2906dbaabeb96f6d75f55357395a..582d804d9c6ca95709f746615c1dd3605dd9364a 100644 --- a/frameworks/native/audiodefinitions/test/unittest/audio_stream_descriptor_unit_test.cpp +++ b/frameworks/native/audiodefinitions/test/unittest/audio_stream_descriptor_unit_test.cpp @@ -1,112 +1,276 @@ -/* - * Copyright (c) 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 - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "audio_stream_descriptor.h" -#include "audio_pipe_info.h" - -#include -#include "audio_common_log.h" -#include "audio_utils.h" -#include - -using namespace testing::ext; -using namespace std; - -namespace OHOS { -namespace AudioStandard { - -static const int32_t MAX_STREAM_DESCRIPTORS_SIZE = 1003; - -class AudioStreamDescriptorUnitTest : public ::testing::Test { -public: - static void SetUpTestCase(){}; - static void TearDownTestCase(){}; - virtual void SetUp(){}; - virtual void TearDown(){}; -}; - -class AudioPipeInfoUnitTest : public ::testing::Test { -public: - static void SetUpTestCase(){}; - static void TearDownTestCase(){}; - virtual void SetUp(){}; - virtual void TearDown(){}; -}; - -/** - * @tc.name : Test InitAudioStreamInfo - * @tc.number : InitAudioStreamInfo_001 - * @tc.desc : Test InitAudioStreamInfo - */ -HWTEST_F(AudioPipeInfoUnitTest, InitAudioStreamInfo_001, TestSize.Level1) -{ - AudioPipeInfo info; - info.InitAudioStreamInfo(); - EXPECT_EQ(info.audioStreamInfo_.format, AudioSampleFormat::INVALID_WIDTH); - - info.moduleInfo_.rate = "48000"; - info.moduleInfo_.channels = "2"; - info.moduleInfo_.format = "s16"; - info.InitAudioStreamInfo(); - EXPECT_NE(info.audioStreamInfo_.format, AudioSampleFormat::INVALID_WIDTH); -} - -/** - * @tc.name : Test WriteDeviceDescVectorToParcel - * @tc.number : WriteDeviceDescVectorToParcel_001 - * @tc.desc : Test WriteDeviceDescVectorToParcel - */ -HWTEST_F(AudioStreamDescriptorUnitTest, WriteDeviceDescVectorToParcel_001, TestSize.Level1) -{ - AudioStreamDescriptor audioStreamDescriptor; - Parcel parcel; - std::vector> descs(MAX_STREAM_DESCRIPTORS_SIZE, - std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE)); - EXPECT_TRUE(audioStreamDescriptor.WriteDeviceDescVectorToParcel(parcel, descs)); -} - -/** - * @tc.name : Test Dump - * @tc.number : Dump_001 - * @tc.desc : Test Dump - */ -HWTEST_F(AudioStreamDescriptorUnitTest, Dump_001, TestSize.Level1) -{ - AudioDeviceDescriptor audioDeviceDescriptor(DeviceType::DEVICE_TYPE_SPEAKER, DeviceRole::OUTPUT_DEVICE); - audioDeviceDescriptor.deviceId_ = 1; - audioDeviceDescriptor.deviceName_ = "BuiltinSpeaker"; - std::string dumpString; - std::string expected = " - device 1: role Output type 2 (SPEAKER) name: BuiltinSpeaker\n"; - audioDeviceDescriptor.Dump(dumpString); - EXPECT_EQ(dumpString, expected); -} - -/** - * @tc.name : Test Dump - * @tc.number : Dump_002 - * @tc.desc : Test Dump - */ -HWTEST_F(AudioStreamDescriptorUnitTest, Dump_002, TestSize.Level1) -{ - AudioDeviceDescriptor audioDeviceDescriptor(DeviceType::DEVICE_TYPE_MIC, DeviceRole::INPUT_DEVICE); - audioDeviceDescriptor.deviceId_ = 2; - audioDeviceDescriptor.deviceName_ = "BuiltinMic"; - std::string dumpString; - std::string expected = " - device 2: role Input type 15 (MIC) name: BuiltinMic\n"; - audioDeviceDescriptor.Dump(dumpString); - EXPECT_EQ(dumpString, expected); -} -} // namespace AudioStandard +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_stream_descriptor.h" + +#include + +#include + +#include "audio_common_log.h" +#include "audio_utils.h" +#include "audio_definitions_unit_test_utils.h" + +using namespace testing::ext; +using namespace std; + +namespace OHOS { +namespace AudioStandard { + +static const int32_t MAX_STREAM_DESCRIPTORS_SIZE = 1003; +static const uint32_t TEST_SET_ROUTE = AUDIO_OUTPUT_FLAG_NORMAL; +static std::string testBundleName = "testBundleName"; + +class AudioStreamDescriptorUnitTest : public ::testing::Test { +public: + static void SetUpTestCase(){}; + static void TearDownTestCase(){}; + virtual void SetUp(); + virtual void TearDown(); + +private: + std::shared_ptr testRendererStream_; + std::shared_ptr testCapturerStream_; +}; + +void AudioStreamDescriptorUnitTest::SetUp() +{ + testRendererStream_ = AudioDefinitionsUnitTestUtil::GenerateCommonStream(AUDIO_MODE_PLAYBACK); + testCapturerStream_ = AudioDefinitionsUnitTestUtil::GenerateCommonStream(AUDIO_MODE_RECORD); +} + +void AudioStreamDescriptorUnitTest::TearDown() +{ + testRendererStream_ = nullptr; + testCapturerStream_ = nullptr; +} + +/** + * @tc.name : AudioStreamDescriptor_AllSimpleGet_001 + * @tc.number : AllSimpleGet_001 + * @tc.desc : Test all simple Get() funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, AllSimpleGet_001, TestSize.Level2) +{ + EXPECT_EQ(true, testRendererStream_->IsPlayback()); + + EXPECT_EQ(false, testRendererStream_->IsRecording()); + + EXPECT_EQ(TEST_RENDERER_SESSION_ID, testRendererStream_->GetSessionId()); + + EXPECT_EQ(false, testRendererStream_->IsRunning()); + + EXPECT_EQ(AUDIO_STREAM_ACTION_DEFAULT, testRendererStream_->GetAction()); +} + +/** + * @tc.name : AudioStreamDescriptor_AudioFlag_001 + * @tc.number : AudioFlag_001 + * @tc.desc : Test audio flag funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, AudioFlag_001, TestSize.Level2) +{ + EXPECT_EQ(AUDIO_FLAG_NONE, testRendererStream_->GetAudioFlag()); + + testRendererStream_->SetAudioFlag(AUDIO_OUTPUT_FLAG_NORMAL); + EXPECT_EQ(false, testRendererStream_->IsUseMoveToConcedeType()); + testRendererStream_->SetAudioFlag(AUDIO_OUTPUT_FLAG_LOWPOWER); + EXPECT_EQ(true, testRendererStream_->IsUseMoveToConcedeType()); + testRendererStream_->SetAudioFlag(AUDIO_OUTPUT_FLAG_MULTICHANNEL); + EXPECT_EQ(true, testRendererStream_->IsUseMoveToConcedeType()); +} + +/** + * @tc.name : AudioStreamDescriptor_RendererRoute_001 + * @tc.number : RendererRoute_001 + * @tc.desc : Test all route funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, RendererRoute_001, TestSize.Level2) +{ + EXPECT_EQ(AUDIO_FLAG_NONE, testRendererStream_->GetRoute()); + + EXPECT_EQ(AUDIO_FLAG_NONE, testRendererStream_->GetOldRoute()); + + EXPECT_EQ(false, testRendererStream_->IsRouteNormal()); + + testRendererStream_->SetRoute(TEST_SET_ROUTE); + EXPECT_EQ(TEST_SET_ROUTE, testRendererStream_->GetRoute()); + + testRendererStream_->SetRoute(AUDIO_OUTPUT_FLAG_NORMAL); + EXPECT_EQ(true, testRendererStream_->IsRouteNormal()); + + testRendererStream_->SetRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + EXPECT_EQ(true, testRendererStream_->IsRouteOffload()); + EXPECT_EQ(true, testRendererStream_->IsNoRunningOffload()); + testRendererStream_->SetStatus(STREAM_STATUS_STARTED); + EXPECT_EQ(false, testRendererStream_->IsNoRunningOffload()); + + testRendererStream_->SetOldRoute(TEST_SET_ROUTE); + EXPECT_EQ(TEST_SET_ROUTE, testRendererStream_->GetOldRoute()); + + testRendererStream_->ResetToNormalRoute(false); + EXPECT_EQ(true, testRendererStream_->IsRouteNormal()); + + testRendererStream_->ResetToNormalRoute(true); + EXPECT_EQ(true, testRendererStream_->IsRouteNormal()); +} + +/** + * @tc.name : AudioStreamDescriptor_CapturerRoute_001 + * @tc.number : CapturerRoute_001 + * @tc.desc : Test all simple route funcs by capturer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, CapturerRoute_001, TestSize.Level2) +{ + testCapturerStream_->SetRoute(AUDIO_INPUT_FLAG_NORMAL); + EXPECT_EQ(true, testCapturerStream_->IsRouteNormal()); + + testCapturerStream_->SetRoute(AUDIO_INPUT_FLAG_FAST); + EXPECT_EQ(false, testCapturerStream_->IsRouteNormal()); + + testCapturerStream_->ResetToNormalRoute(false); + EXPECT_EQ(true, testCapturerStream_->IsRouteNormal()); + + testCapturerStream_->ResetToNormalRoute(true); + EXPECT_EQ(true, testCapturerStream_->IsRouteNormal()); +} + +/** + * @tc.name : AudioStreamDescriptor_RendererDevice_001 + * @tc.number : RendererDevice_001 + * @tc.desc : Test all simple device funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, RendererDevice_001, TestSize.Level2) +{ + EXPECT_EQ(DEVICE_TYPE_NONE, testRendererStream_->GetMainNewDeviceType()); + + auto device = std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + testRendererStream_->AddNewDevice(device); + EXPECT_EQ(DEVICE_TYPE_SPEAKER, testRendererStream_->GetMainNewDeviceType()); + + device = std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + device->networkId_ = LOCAL_NETWORK_ID; + std::vector> devices; + devices.push_back(device); + testRendererStream_->UpdateNewDevice(devices); + EXPECT_EQ(false, testRendererStream_->IsDeviceRemote()); + + device = std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + device->networkId_ = REMOTE_NETWORK_ID; + devices.clear(); + devices.push_back(device); + testRendererStream_->UpdateNewDevice(devices); + EXPECT_EQ(true, testRendererStream_->IsDeviceRemote()); +} + +/** + * @tc.name : AudioStreamDescriptor_RendererDevice_002 + * @tc.number : RendererDevice_002 + * @tc.desc : Test device funcs error branches by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, RendererDevice_002, TestSize.Level4) +{ + auto device = std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + testRendererStream_->AddNewDevice(device); + EXPECT_EQ(DEVICE_TYPE_SPEAKER, testRendererStream_->GetMainNewDeviceType()); + + testRendererStream_->AddNewDevice(nullptr); + EXPECT_EQ(DEVICE_TYPE_SPEAKER, testRendererStream_->GetMainNewDeviceType()); + + std::vector> devices; + devices.push_back(nullptr); + testRendererStream_->UpdateNewDevice(devices); + EXPECT_EQ(DEVICE_TYPE_SPEAKER, testRendererStream_->GetMainNewDeviceType()); +} + +/** + * @tc.name : AudioStreamDescriptor_Dump_001 + * @tc.number : Dump_001 + * @tc.desc : Test dump funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, Dump_001, TestSize.Level3) +{ + auto device = std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + testRendererStream_->AddNewDevice(device); + + std::string outDump; + testRendererStream_->Dump(outDump); + EXPECT_NE("", outDump); +} + +/** + * @tc.name : AudioStreamDescriptor_DeviceString_001 + * @tc.number : DeviceString_001 + * @tc.desc : Test device string funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, DeviceString_001, TestSize.Level3) +{ + auto device = std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + testRendererStream_->AddNewDevice(device); + std::string devicesTypeStr = testRendererStream_->GetNewDevicesTypeString(); + EXPECT_NE("", devicesTypeStr); + + std::string devicesInfoStr = testRendererStream_->GetNewDevicesInfo(); + EXPECT_NE("", devicesInfoStr); + + std::string deviceInfoStr = testRendererStream_->GetDeviceInfo(device); + EXPECT_NE("", deviceInfoStr); +} + +/** + * @tc.name : AudioStreamDescriptor_BundleName_001 + * @tc.number : BundleName_001 + * @tc.desc : Test bundle name funcs by renderer AudioStreamDescriptor instance + */ +HWTEST_F(AudioStreamDescriptorUnitTest, BundleName_001, TestSize.Level3) +{ + testRendererStream_->SetBunduleName(testBundleName); + EXPECT_EQ(testBundleName, testRendererStream_->GetBundleName()); +} + +/** + * @tc.name : AudioStreamDescriptor_Marshalling_001 + * @tc.number : Marshalling_001 + * @tc.desc : Test marshall and unmarshall funcs + */ +HWTEST_F(AudioStreamDescriptorUnitTest, Marshalling_001, TestSize.Level3) +{ + Parcel testParcel; + testRendererStream_->Marshalling(testParcel); + AudioStreamDescriptor *outStream = AudioStreamDescriptor::Unmarshalling(testParcel); + EXPECT_EQ(testRendererStream_->IsPlayback(), outStream->IsPlayback()); + EXPECT_EQ(testRendererStream_->GetSessionId(), outStream->GetSessionId()); + EXPECT_EQ(testRendererStream_->GetAction(), outStream->GetAction()); + EXPECT_EQ(testRendererStream_->GetRoute(), outStream->GetRoute()); + delete outStream; +} + +/** + * @tc.name : Test WriteDeviceDescVectorToParcel + * @tc.number : WriteDeviceDescVectorToParcel_001 + * @tc.desc : Test WriteDeviceDescVectorToParcel + */ +HWTEST_F(AudioStreamDescriptorUnitTest, WriteDeviceDescVectorToParcel_001, TestSize.Level1) +{ + AudioStreamDescriptor audioStreamDescriptor; + Parcel parcel; + std::vector> descs(MAX_STREAM_DESCRIPTORS_SIZE, + std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE)); + EXPECT_TRUE(audioStreamDescriptor.WriteDeviceDescVectorToParcel(parcel, descs)); +} + + +} // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp b/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp index 9e1f55cc904ad892ea20b88b9db17e87b9a61fac..93d87c1517d3738ccc6f9d71e890b0df1d3a5380 100644 --- a/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp +++ b/frameworks/native/audioeffect/src/audio_effect_chain_manager.cpp @@ -37,6 +37,8 @@ const std::unordered_map AUDIO_PERSISTENCE_EFFECT_KEY }; const std::vector AUDIO_PERSISTENCE_SCENE {"SCENE_VOIP_DOWN"}; } + +// LCOV_EXCL_START static int32_t CheckValidEffectLibEntry(const std::shared_ptr &libEntry, const std::string &effect, const std::string &libName) { @@ -54,6 +56,7 @@ static int32_t CheckValidEffectLibEntry(const std::shared_ptr> &effectLibraryList, @@ -115,6 +118,7 @@ AudioEffectChainManager *AudioEffectChainManager::GetInstance() return &audioEffectChainManager; } +// LCOV_EXCL_START int32_t AudioEffectChainManager::UpdateDeviceInfo(int32_t device, const std::string &sinkName) { if (!isInitialized_) { @@ -135,7 +139,9 @@ int32_t AudioEffectChainManager::UpdateDeviceInfo(int32_t device, const std::str return SUCCESS; } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::SetSpkOffloadState() { int32_t ret; @@ -170,7 +176,9 @@ void AudioEffectChainManager::SetSpkOffloadState() RecoverAllChains(); } } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::SetOutputDeviceSink(int32_t device, const std::string &sinkName) { std::lock_guard lock(dynamicMutex_); @@ -181,6 +189,7 @@ void AudioEffectChainManager::SetOutputDeviceSink(int32_t device, const std::str SetSpkOffloadState(); return; } +// LCOV_EXCL_STOP std::string AudioEffectChainManager::GetDeviceTypeName() { @@ -443,6 +452,7 @@ int32_t AudioEffectChainManager::ApplyAudioEffectChain(const std::string &sceneT return SUCCESS; } +// LCOV_EXCL_START int32_t AudioEffectChainManager::EffectDspVolumeUpdate(std::shared_ptr audioEffectVolume) { CHECK_AND_RETURN_RET_LOG(audioEffectVolume != nullptr, ERROR, "null audioEffectVolume"); @@ -477,6 +487,7 @@ int32_t AudioEffectChainManager::EffectDspVolumeUpdate(std::shared_ptr audioEffectVolume) { @@ -506,6 +517,7 @@ int32_t AudioEffectChainManager::EffectApVolumeUpdate(std::shared_ptr audioEffectVolume) { CHECK_AND_RETURN_RET_LOG(audioEffectVolume != nullptr, ERROR, "null audioEffectVolume"); @@ -539,6 +551,7 @@ int32_t AudioEffectChainManager::SendEffectApVolume(std::shared_ptr audioEffectRotation, const uint32_t rotationState) { @@ -633,6 +647,7 @@ int32_t AudioEffectChainManager::EffectApRotationUpdate(std::shared_ptr lock(dynamicMutex_); @@ -746,6 +764,7 @@ int32_t AudioEffectChainManager::ReturnMultiChannelInfo(uint32_t *channels, uint } return SUCCESS; } +// LCOV_EXCL_STOP int32_t AudioEffectChainManager::SessionInfoMapAdd(const std::string &sessionID, const SessionEffectInfo &info) { @@ -800,6 +819,7 @@ int32_t AudioEffectChainManager::SetHdiParam(const AudioEffectScene &sceneType) return SUCCESS; } +// LCOV_EXCL_START int32_t AudioEffectChainManager::QueryHdiSupportedChannelInfo(uint32_t &channels, uint64_t &channelLayout) { std::lock_guard lock(dynamicMutex_); @@ -845,7 +865,9 @@ int32_t AudioEffectChainManager::QueryHdiSupportedChannelInfo(uint32_t &channels } return SUCCESS; } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::UpdateSensorState() { effectHdiInput_[0] = HDI_HEAD_MODE; @@ -897,6 +919,7 @@ void AudioEffectChainManager::UpdateSensorState() } #endif } +// LCOV_EXCL_STOP void AudioEffectChainManager::DeleteAllChains() { @@ -929,6 +952,7 @@ void AudioEffectChainManager::RecoverAllChains() UpdateStreamUsageInner(); } +// LCOV_EXCL_START uint32_t AudioEffectChainManager::GetLatency(const std::string &sessionId) { std::lock_guard lock(dynamicMutex_); @@ -950,6 +974,7 @@ uint32_t AudioEffectChainManager::GetLatency(const std::string &sessionId) sceneTypeToEffectChainMap_[sceneTypeAndDeviceKey] != nullptr, 0); return sceneTypeToEffectChainMap_[sceneTypeAndDeviceKey]->GetLatency(); } +// LCOV_EXCL_STOP int32_t AudioEffectChainManager::SetSpatializationSceneType(AudioSpatializationSceneType spatializationSceneType) { @@ -972,6 +997,7 @@ int32_t AudioEffectChainManager::SetSpatializationSceneType(AudioSpatializationS return SUCCESS; } +// LCOV_EXCL_START void AudioEffectChainManager::SendAudioParamToHDI( HdiSetParamCommandCode code, const std::string &value, DeviceType device) { @@ -982,7 +1008,9 @@ void AudioEffectChainManager::SendAudioParamToHDI( AUDIO_WARNING_LOG("set hdi parameter failed for code %{public}d and value %{public}s", code, value.c_str()); } } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::SendAudioParamToARM(HdiSetParamCommandCode code, const std::string &value) { for (const auto &[scene, audioEffectChain] : sceneTypeToEffectChainMap_) { @@ -1014,7 +1042,9 @@ void AudioEffectChainManager::SendAudioParamToARM(HdiSetParamCommandCode code, c } } } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::UpdateParamExtra( const std::string &mainkey, const std::string &subkey, const std::string &value) { @@ -1038,7 +1068,9 @@ void AudioEffectChainManager::UpdateParamExtra( return; } } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::SetSpatializationSceneTypeToChains() { for (auto it = sceneTypeToEffectChainMap_.begin(); it != sceneTypeToEffectChainMap_.end(); ++it) { @@ -1053,7 +1085,9 @@ void AudioEffectChainManager::SetSpatializationSceneTypeToChains() } } } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::SetSpatializationEnabledToChains() { for (auto it = sceneTypeToEffectChainMap_.begin(); it != sceneTypeToEffectChainMap_.end(); ++it) { @@ -1064,6 +1098,7 @@ void AudioEffectChainManager::SetSpatializationEnabledToChains() audioEffectChain->SetSpatializationEnabledForFading(spatializationEnabled_); } } +// LCOV_EXCL_STOP void AudioEffectChainManager::ResetInfo() { @@ -1136,6 +1171,7 @@ void AudioEffectChainManager::UpdateStreamUsage() UpdateStreamUsageInner(); } +// LCOV_EXCL_START void AudioEffectChainManager::UpdateStreamUsageInner() { // for special scene type @@ -1183,7 +1219,9 @@ void AudioEffectChainManager::UpdateStreamUsageInner() // update dsp scene type and stream usage UpdateCurrSceneTypeAndStreamUsageForDsp(); } +// LCOV_EXCL_STOP +// LCOV_EXCL_START bool AudioEffectChainManager::CheckSceneTypeMatch(const std::string &sinkSceneType, const std::string &sceneType) { std::lock_guard lock(dynamicMutex_); @@ -1204,6 +1242,7 @@ bool AudioEffectChainManager::CheckSceneTypeMatch(const std::string &sinkSceneTy } return false; } +// LCOV_EXCL_STOP void AudioEffectChainManager::UpdateCurrSceneType(AudioEffectScene &currSceneType, const std::string &sceneType) { @@ -1211,6 +1250,7 @@ void AudioEffectChainManager::UpdateCurrSceneType(AudioEffectScene &currSceneTyp currSceneType = static_cast(GetKeyFromValue(audioSupportedSceneTypes, sceneType)); } +// LCOV_EXCL_START void AudioEffectChainManager::FindMaxEffectChannels(const std::string &sceneType, const std::set &sessions, uint32_t &channels, uint64_t &channelLayout) { @@ -1234,6 +1274,7 @@ void AudioEffectChainManager::FindMaxEffectChannels(const std::string &sceneType } } } +// LCOV_EXCL_STOP std::shared_ptr AudioEffectChainManager::CreateAudioEffectChain(const std::string &sceneType, bool isPriorScene) @@ -1280,6 +1321,7 @@ std::shared_ptr AudioEffectChainManager::CreateAudioEffectChai return audioEffectChain; } +// LCOV_EXCL_START int32_t AudioEffectChainManager::CheckAndReleaseCommonEffectChain(const std::string &sceneType) { AUDIO_INFO_LOG("release effect chain for scene type: %{public}s", sceneType.c_str()); @@ -1309,7 +1351,9 @@ int32_t AudioEffectChainManager::CheckAndReleaseCommonEffectChain(const std::str } return ERROR; } +// LCOV_EXCL_STOP +// LCOV_EXCL_START void AudioEffectChainManager::UpdateSpatializationEnabled(AudioSpatializationState spatializationState) { spatializationEnabled_ = spatializationState.spatializationEnabled; @@ -1345,6 +1389,8 @@ void AudioEffectChainManager::UpdateSpatializationEnabled(AudioSpatializationSta } SetSpatializationEnabledToChains(); } +// LCOV_EXCL_STOP + // for AISS temporarily bool AudioEffectChainManager::CheckIfSpkDsp() { @@ -1396,6 +1442,7 @@ int32_t AudioEffectChainManager::SetAudioEffectProperty(const AudioEffectPropert return ret; } +// LCOV_EXCL_START void AudioEffectChainManager::LoadEffectProperties() { hasLoadedEffectProperties_ = false; @@ -1417,7 +1464,9 @@ void AudioEffectChainManager::LoadEffectProperties() } hasLoadedEffectProperties_ = true; } +// LCOV_EXCL_STOP +// LCOV_EXCL_START int32_t AudioEffectChainManager::SetAudioEffectProperty(const AudioEffectPropertyArray &propertyArray) { std::lock_guard lock(dynamicMutex_); @@ -1431,6 +1480,7 @@ int32_t AudioEffectChainManager::SetAudioEffectProperty(const AudioEffectPropert } return AUDIO_OK; } +// LCOV_EXCL_STOP int32_t AudioEffectChainManager::GetAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray) { @@ -1497,6 +1547,7 @@ int32_t AudioEffectChainManager::UpdateSceneTypeList(const std::string &sceneTyp return SUCCESS; } +// LCOV_EXCL_START uint32_t AudioEffectChainManager::GetSceneTypeToChainCount(const std::string &sceneType) { std::lock_guard lock(dynamicMutex_); @@ -1518,6 +1569,7 @@ uint32_t AudioEffectChainManager::GetSceneTypeToChainCount(const std::string &sc } return 0; } +// LCOV_EXCL_STOP void AudioEffectChainManager::FindMaxSessionID(uint32_t &maxSessionID, std::string &sceneType, const std::string &scenePairType, std::set &sessions) diff --git a/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp b/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp index f4f98187f966901d469040e040b75af6e25a633b..4b2f34b26abfbcabd908819572f597aac5378433 100644 --- a/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp +++ b/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp @@ -73,7 +73,7 @@ void AudioLoopbackUnitTest::TearDown(void) {} HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_001, TestSize.Level0) { -#ifdef TEMP_DISABLED +#ifdef TEMP_DISABLE auto audioLoopback = AudioLoopback::CreateAudioLoopback(LOOPBACK_HARDWARE, AppInfo()); EXPECT_NE(audioLoopback, nullptr); #endif @@ -90,7 +90,7 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_002, TestSize HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_003, TestSize.Level1) { -#ifdef TEMP_DISABLED +#ifdef TEMP_DISABLE auto audioLoopback = std::make_shared(LOOPBACK_HARDWARE, AppInfo()); audioLoopback->CreateAudioLoopback(); EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING); @@ -122,7 +122,7 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_005, TestSize HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_006, TestSize.Level1) { -#ifdef TEMP_DISABLED +#ifdef TEMP_DISABLE auto audioLoopback = std::make_shared(LOOPBACK_HARDWARE, AppInfo()); audioLoopback->isRendererUsb_ = true; audioLoopback->isCapturerUsb_ = true; @@ -140,7 +140,7 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_006, TestSize HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_007, TestSize.Level1) { -#ifdef TEMP_DISABLED +#ifdef TEMP_DISABLE auto audioLoopback = std::make_shared(LOOPBACK_HARDWARE, AppInfo()); audioLoopback->CreateAudioLoopback(); EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING); @@ -153,7 +153,7 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_007, TestSize HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_008, TestSize.Level1) { -#ifdef TEMP_DISABLED +#ifdef TEMP_DISABLE auto audioLoopback = std::make_shared(LOOPBACK_HARDWARE, AppInfo()); audioLoopback->CreateAudioLoopback(); EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING); diff --git a/frameworks/native/audiopolicy/include/audio_policy_manager.h b/frameworks/native/audiopolicy/include/audio_policy_manager.h index cf626db6cdcd0b0f2c36a42568b05e53d9ff0315..e7ed0c67730d907be41eef9c354c8eca5d86f9dd 100644 --- a/frameworks/native/audiopolicy/include/audio_policy_manager.h +++ b/frameworks/native/audiopolicy/include/audio_policy_manager.h @@ -589,8 +589,6 @@ public: int32_t UnsetAudioDeviceAnahsCallback(); - int32_t MoveToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType); - void ResetClientTrackerStubMap(); void RemoveClientTrackerStub(int32_t sessionId); diff --git a/frameworks/native/audiorenderer/include/audio_renderer_private.h b/frameworks/native/audiorenderer/include/audio_renderer_private.h index 2754afce03011a3f94bd3aa3c56627b3d72bcdc8..6baf87e5c8b6a9f2e7e8f75d4383bf57f36f3c01 100644 --- a/frameworks/native/audiorenderer/include/audio_renderer_private.h +++ b/frameworks/native/audiorenderer/include/audio_renderer_private.h @@ -214,7 +214,6 @@ private: IAudioStream::SwitchInfo &info); bool GenerateNewStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo, RendererState previousState, IAudioStream::SwitchInfo &info); - bool ContinueAfterConcede(IAudioStream::StreamClass &targetClass, RestoreInfo restoreInfo); bool ContinueAfterSplit(RestoreInfo restoreInfo); bool InitTargetStream(IAudioStream::SwitchInfo &info, std::shared_ptr &audioStream); void HandleAudioInterruptWhenServerDied(); diff --git a/frameworks/native/audiorenderer/src/audio_renderer.cpp b/frameworks/native/audiorenderer/src/audio_renderer.cpp index 2f69947299ddcef00eceb2b829df05cb2fc09e17..a4a4e2a7863f8e260d272491f7165b82572df8cd 100644 --- a/frameworks/native/audiorenderer/src/audio_renderer.cpp +++ b/frameworks/native/audiorenderer/src/audio_renderer.cpp @@ -1001,9 +1001,6 @@ int32_t AudioRendererPrivate::CheckAndRestoreAudioRenderer(std::string callingFu } // Check if split stream. If true, fetch output device and return. CHECK_AND_RETURN_RET(ContinueAfterSplit(restoreInfo), true, "Stream split"); - // Check if continue to switch after some concede operation. - CHECK_AND_RETURN_RET_LOG(ContinueAfterConcede(targetClass, restoreInfo), - true, "No need for switch"); oldStream = audioStream_; } // ahead join callbackLoop and do not hold rendererMutex_ when waiting for callback @@ -2223,6 +2220,10 @@ bool AudioRendererPrivate::FinishOldStream(IAudioStream::StreamClass targetClass AUDIO_INFO_LOG("Server died, reset session id: %{public}d", switchInfo.params.originalSessionId); switchInfo.params.originalSessionId = 0; switchInfo.sessionId = 0; + switchInfo.lastFramePosAndTimePairWithSpeed[Timestamp::Timestampbase::MONOTONIC].first = + switchInfo.unprocessSamples; + switchInfo.lastFramePosAndTimePairWithSpeed[Timestamp::Timestampbase::BOOTTIME].first = + switchInfo.unprocessSamples; } UpdateFramesWritten(); switchResult = audioStream_->ReleaseAudioStream(true, true); @@ -2261,7 +2262,7 @@ bool AudioRendererPrivate::GenerateNewStream(IAudioStream::StreamClass targetCla switchInfo.sessionId = switchInfo.params.originalSessionId; streamDesc->sessionId_ = switchInfo.params.originalSessionId; } - streamDesc->rendererInfo_.rendererFlags = AUDIO_FLAG_FORCED_NORMAL; + streamDesc->rendererInfo_.forceToNormal = true; streamDesc->routeFlag_ = AUDIO_FLAG_NONE; int32_t ret = AudioPolicyManager::GetInstance().CreateRendererClient(streamDesc, flag, switchInfo.params.originalSessionId, networkId); @@ -2296,32 +2297,6 @@ bool AudioRendererPrivate::GenerateNewStream(IAudioStream::StreamClass targetCla return switchResult; } -bool AudioRendererPrivate::ContinueAfterConcede(IAudioStream::StreamClass &targetClass, RestoreInfo restoreInfo) -{ - CHECK_AND_RETURN_RET(restoreInfo.restoreReason == STREAM_CONCEDED, true); - targetClass = IAudioStream::PA_STREAM; - uint32_t sessionId = sessionID_; - GetAudioStreamIdInner(sessionId); - AudioPipeType pipeType = PIPE_TYPE_NORMAL_OUT; - audioStream_->GetAudioPipeType(pipeType); - AUDIO_INFO_LOG("session %{public}u concede from pipeType %{public}d", sessionID_, rendererInfo_.pipeType); - rendererInfo_.pipeType = PIPE_TYPE_NORMAL_OUT; - rendererInfo_.isOffloadAllowed = false; - audioStream_->SetRendererInfo(rendererInfo_); - if (pipeType == PIPE_TYPE_OFFLOAD) { - UnsetOffloadModeInner(); - AudioPolicyManager::GetInstance().MoveToNewPipe(sessionId, PIPE_TYPE_NORMAL_OUT); - audioStream_->SetRestoreStatus(NO_NEED_FOR_RESTORE); - return false; - } - if ((pipeType == PIPE_TYPE_LOWLATENCY_OUT && audioStream_->GetStreamClass() != IAudioStream::PA_STREAM) || - pipeType == PIPE_TYPE_DIRECT_MUSIC) { - return true; - } - audioStream_->SetRestoreStatus(NO_NEED_FOR_RESTORE); - return false; -} - bool AudioRendererPrivate::ContinueAfterSplit(RestoreInfo restoreInfo) { CHECK_AND_RETURN_RET(restoreInfo.restoreReason == STREAM_SPLIT, true); @@ -2932,12 +2907,12 @@ int32_t AudioRendererPrivate::HandleCreateFastStreamError(AudioStreamParams &aud AUDIO_INFO_LOG("Create fast Stream fail, play by normal stream."); IAudioStream::StreamClass streamClass = IAudioStream::PA_STREAM; isFastRenderer_ = false; - rendererInfo_.rendererFlags = AUDIO_FLAG_FORCED_NORMAL; // Create stream desc and pipe std::shared_ptr streamDesc = ConvertToStreamDescriptor(audioStreamParams); uint32_t flag = AUDIO_OUTPUT_FLAG_NORMAL; std::string networkId = LOCAL_NETWORK_ID; + streamDesc->rendererInfo_.forceToNormal = true; int32_t ret = AudioPolicyManager::GetInstance().CreateRendererClient(streamDesc, flag, audioStreamParams.originalSessionId, networkId); CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "CreateRendererClient failed"); diff --git a/frameworks/native/audiorenderer/test/unittest/renderer_test/include/audio_renderer_unit_test.h b/frameworks/native/audiorenderer/test/unittest/renderer_test/include/audio_renderer_unit_test.h index b87890988501171343818a5c38bf2720641b4df7..24b85f762de1b1a36ad3ac8a6204772726302d11 100644 --- a/frameworks/native/audiorenderer/test/unittest/renderer_test/include/audio_renderer_unit_test.h +++ b/frameworks/native/audiorenderer/test/unittest/renderer_test/include/audio_renderer_unit_test.h @@ -59,6 +59,7 @@ constexpr int32_t MIN_CACHE_SIZE = 3528; inline size_t g_reqBufLen = 0; constexpr int g_writeOverflowNum = 1000; +constexpr float DUCK_VOLUME = 0.2f; void StartRenderThread(AudioRenderer *audioRenderer, uint32_t limit); } @@ -102,7 +103,7 @@ public: class TestAudioStremStub : public FastAudioStream { public: TestAudioStremStub() : FastAudioStream(AudioStreamType::STREAM_MUSIC, - AudioMode::AUDIO_MODE_RECORD, 0) {} + AudioMode::AUDIO_MODE_PLAYBACK, 0) {} uint32_t GetOverflowCount() override { return RenderUT::g_writeOverflowNum; } State GetState() override { return state_; } bool StopAudioStream() override { return true; } @@ -119,6 +120,8 @@ public: const std::shared_ptr &proxyObj, const AudioPlaybackCaptureConfig &config = AudioPlaybackCaptureConfig()) override { return SUCCESS; } void GetRestoreInfo(RestoreInfo &restoreInfo) override {}; + float GetDuckVolume() override { return RenderUT::DUCK_VOLUME; } + int32_t SetDuckVolume(float volume) override { return SUCCESS; } State state_ = State::RUNNING; RestoreStatus restoreStatus_ = NO_NEED_FOR_RESTORE; diff --git a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp index 1f251e0e9582c67882cd6c1970f73c007d5423fd..b02cf2fcf2b854afbc4f07fd8b902035b8fc0217 100644 --- a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp +++ b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp @@ -4259,15 +4259,14 @@ HWTEST(AudioRendererUnitTest, Audio_Renderer_InitTargetStream_002, TestSize.Leve * @tc.number: Audio_Renderer_FinishOldStream_001 * @tc.desc : Test FinishOldStream interface. */ -HWTEST(AudioRendererUnitTest, Audio_Renderer_FinishOldStream_001, TestSize.Level2) +HWTEST(AudioRendererUnitTest, Audio_Renderer_FinishOldStream_001, TestSize.Level4) { AppInfo appInfo = {}; std::shared_ptr audioRendererPrivate = std::make_shared(AudioStreamType::STREAM_MEDIA, appInfo); ASSERT_TRUE(audioRendererPrivate != nullptr); - std::shared_ptr audioStream = std::make_shared(STREAM_MUSIC, AUDIO_MODE_PLAYBACK, - appInfo.appUid); + std::shared_ptr audioStream = std::make_shared(); ASSERT_TRUE(audioStream != nullptr); audioRendererPrivate->audioStream_ = audioStream; @@ -4292,8 +4291,7 @@ HWTEST(AudioRendererUnitTest, Audio_Renderer_FinishOldStream_002, TestSize.Level std::make_shared(AudioStreamType::STREAM_MEDIA, appInfo); ASSERT_TRUE(audioRendererPrivate != nullptr); - std::shared_ptr audioStream = std::make_shared(STREAM_MUSIC, AUDIO_MODE_PLAYBACK, - appInfo.appUid); + std::shared_ptr audioStream = std::make_shared(); ASSERT_TRUE(audioStream != nullptr); audioRendererPrivate->audioStream_ = audioStream; @@ -4303,33 +4301,7 @@ HWTEST(AudioRendererUnitTest, Audio_Renderer_FinishOldStream_002, TestSize.Level restoreInfo.restoreReason = DEFAULT_REASON; auto ret = audioRendererPrivate->FinishOldStream(IAudioStream::StreamClass::PA_STREAM, restoreInfo, previousState, switchInfo); - EXPECT_FALSE(ret); -} - -/** - * @tc.name : Test ContinueAfterConcede API. - * @tc.number: Audio_Renderer_ContinueAfterConcede_001 - * @tc.desc : Test ContinueAfterConcede interface. - */ -HWTEST(AudioRendererUnitTest, Audio_Renderer_ContinueAfterConcede_001, TestSize.Level2) -{ - AppInfo appInfo = {}; - std::shared_ptr audioRendererPrivate = - std::make_shared(AudioStreamType::STREAM_MEDIA, appInfo); - ASSERT_TRUE(audioRendererPrivate != nullptr); - - AudioStreamParams tempParams = {}; - AudioStreamType audioStreamType = STREAM_MUSIC; - auto audioStream = IAudioStream::GetPlaybackStream(IAudioStream::PA_STREAM, tempParams, audioStreamType, - appInfo.appUid); - ASSERT_TRUE(audioStream != nullptr); - audioRendererPrivate->audioStream_ = audioStream; - - RestoreInfo restoreInfo; - IAudioStream::StreamClass targetClass = IAudioStream::StreamClass::PA_STREAM; - restoreInfo.restoreReason = STREAM_CONCEDED; - auto ret = audioRendererPrivate->ContinueAfterConcede(targetClass, restoreInfo); - EXPECT_FALSE(ret); + EXPECT_TRUE(ret); } /** diff --git a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp index b76dfcce4bc7f2aa3d28f57db2d1a13000e5cb37..50b95b8ce48d44df7031b6b673f3d42a7773f62f 100644 --- a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp +++ b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp @@ -2626,5 +2626,31 @@ HWTEST(RendererInClientInnerUnitTest, SetOffloadDataCallbackState_002, TestSize. int cbState = 1; EXPECT_EQ(ptrRendererInClientInner->SetOffloadDataCallbackState(cbState), SUCCESS); } + +/** + * @tc.name : Test RecordDropPosition API + * @tc.type : FUNC + * @tc.number: RecordDropPosition_001 + * @tc.desc : Test RendererInClientInner::RecordDropPosition + */ +HWTEST(RendererInClientInnerUnitTest, RecordDropPosition_001, TestSize.Level1) +{ + auto ptrRendererInClientInner = std::make_shared(AudioStreamType::STREAM_DEFAULT, getpid()); + AudioProcessConfig config = {}; + config.streamInfo.channels = AudioChannel::STEREO; + config.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE; + ptrRendererInClientInner->clientConfig_ = config; + + ptrRendererInClientInner->isHdiSpeed_.store(false); + ptrRendererInClientInner->RecordDropPosition(60); + EXPECT_EQ(ptrRendererInClientInner->dropPosition_, 0); + EXPECT_EQ(ptrRendererInClientInner->dropHdiPosition_, 0); + + ptrRendererInClientInner->isHdiSpeed_.store(true); + ptrRendererInClientInner->realSpeed_ = 2.0f; + ptrRendererInClientInner->RecordDropPosition(60); + EXPECT_EQ(ptrRendererInClientInner->dropPosition_, 10); + EXPECT_EQ(ptrRendererInClientInner->dropHdiPosition_, 5); +} } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/native/audiostream/include/i_audio_stream.h b/frameworks/native/audiostream/include/i_audio_stream.h index 174a5e1e9bf5220a695485330f15d40f82664eb2..73eea8c4e1b6c322228e89ffa5ca3e2d30aa5f94 100644 --- a/frameworks/native/audiostream/include/i_audio_stream.h +++ b/frameworks/native/audiostream/include/i_audio_stream.h @@ -84,6 +84,7 @@ public: uint64_t frameMarkPosition = 0; uint64_t framePeriodNumber = 0; + uint64_t unprocessSamples = 0; uint64_t totalBytesWritten = 0; uint64_t framePeriodWritten = 0; std::shared_ptr renderPositionCb; diff --git a/frameworks/native/audioutils/include/audio_utils.h b/frameworks/native/audioutils/include/audio_utils.h index 6ff63c5a43ad122581a7d2021da897ae0171cd14..1c884eda976a5bbe7223fa9510029f5a0493a2bc 100644 --- a/frameworks/native/audioutils/include/audio_utils.h +++ b/frameworks/native/audioutils/include/audio_utils.h @@ -554,6 +554,7 @@ enum HdiCaptureOffset : uint32_t { HDI_CAPTURE_OFFSET_WAKEUP = 8, HDI_CAPTURE_OFFSET_BLUETOOTH = 9, HDI_CAPTURE_OFFSET_ACCESSORY = 10, + HDI_CAPTURE_OFFSET_VOICE_TRANSCRIPTION = 11, }; enum HdiRenderOffset : uint32_t { diff --git a/frameworks/native/audioutils/src/audio_utils.cpp b/frameworks/native/audioutils/src/audio_utils.cpp index c6f549b05290401c63b4084160c856bbfddad94b..9ea0c5c8e652fdaae733847384bb0f77c2c55f3e 100644 --- a/frameworks/native/audioutils/src/audio_utils.cpp +++ b/frameworks/native/audioutils/src/audio_utils.cpp @@ -609,25 +609,6 @@ bool SwitchStreamUtil::InsertSwitchStreamRecord(SwitchStreamInfo &info, SwitchSt return true; } -void SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(SwitchStreamInfo info, SwitchState targetState) -{ - const std::chrono::seconds TIMEOUT_DURATION(2); - AUDIO_INFO_LOG("Start timing. It will change to SWITCH_STATE_TIMEOUT after 2 seconds."); - std::this_thread::sleep_for(TIMEOUT_DURATION); - - { - std::lock_guard lock(g_switchMapMutex); - auto it = g_switchStreamRecordMap.find(info); - if (it != g_switchStreamRecordMap.end()) { - it->second = SWITCH_STATE_TIMEOUT; - g_switchStreamRecordMap.erase(it); - AUDIO_INFO_LOG("SwitchStream:%{public}u uid:%{public}d CapturerState:%{public}d was timeout! " - "Update Record switchState:%{public}d success", - info.sessionId, info.appUid, info.nextState, SWITCH_STATE_TIMEOUT); - } - } -} - //Remove switchStreamInfo from switchStreamRecordMap must be called with g_switchMapMutex held bool SwitchStreamUtil::RemoveSwitchStreamRecord(SwitchStreamInfo &info, SwitchState targetState) { @@ -674,7 +655,7 @@ bool SwitchStreamUtil::UpdateSwitchStreamRecord(SwitchStreamInfo &info, SwitchSt false, "Remove error record for switchStream:%{public}u failed!", iter->first.sessionId); CHECK_AND_RETURN_RET_LOG(SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState), false, "Retry insert switchStream into record failed!"); - break; + return true; case SWITCH_STATE_CREATED: CHECK_AND_RETURN_RET_LOG(HandleCreatedSwitchInfoInRecord(info, targetState), false, "Handle switch record to SWITCH_STATE_CREATED failed!"); @@ -688,17 +669,15 @@ bool SwitchStreamUtil::UpdateSwitchStreamRecord(SwitchStreamInfo &info, SwitchSt "Handle switch info in record failed!"); break; } + iter = g_switchStreamRecordMap.find(info); + CHECK_AND_RETURN_RET_LOG(iter != g_switchStreamRecordMap.end(), false, "SwitchStream has been removed!"); if (iter->first.nextState == info.nextState) { g_switchStreamRecordMap[info] = SWITCH_STATE_FINISHED; g_switchStreamRecordMap.erase(info); AUDIO_INFO_LOG("SwitchStream will finish!Remove Record for stream:%{public}u uid:%{public}d ", info.sessionId, info.appUid); } - if (iter->second == SWITCH_STATE_TIMEOUT || iter->second == SWITCH_STATE_FINISHED) { - CHECK_AND_RETURN_RET_LOG(SwitchStreamUtil::RemoveSwitchStreamRecord(info, targetState), false, - "Remove TIMEOUT or FINISHED Record for Stream:%{public}u Failed!", iter->first.sessionId); - return false; - } + return true; } diff --git a/frameworks/native/audioutils/test/unittest/audio_utils_pro_unit_test.cpp b/frameworks/native/audioutils/test/unittest/audio_utils_pro_unit_test.cpp index 3f9a94243f151bb36c6c870fcde82447eca9d9a4..6c18bf61bad9fd4c89b4a9fc231e0499c3c37317 100644 --- a/frameworks/native/audioutils/test/unittest/audio_utils_pro_unit_test.cpp +++ b/frameworks/native/audioutils/test/unittest/audio_utils_pro_unit_test.cpp @@ -251,50 +251,6 @@ HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_009, TestSize.Level1) EXPECT_EQ(ret, true); } -/** -* @tc.name : Test SwitchStreamUtil API -* @tc.type : FUNC -* @tc.number: SwitchStreamUtil_010 -* @tc.desc : Test SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(). -*/ -HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_010, TestSize.Level1) -{ - SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED}; - SwitchState targetState = SwitchState::SWITCH_STATE_CREATED; - - SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState); - - SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED}; - SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED; - - SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(info2, targetState2); - - auto ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0); - EXPECT_EQ(ret, true); -} - -/** -* @tc.name : Test SwitchStreamUtil API -* @tc.type : FUNC -* @tc.number: SwitchStreamUtil_011 -* @tc.desc : Test SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(). -*/ -HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_011, TestSize.Level1) -{ - SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING}; - SwitchState targetState = SwitchState::SWITCH_STATE_CREATED; - - SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState); - - SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED}; - SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED; - - SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(info2, targetState2); - - auto ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0); - EXPECT_EQ(ret, true); -} - /** * @tc.name : Test SwitchStreamUtil API * @tc.type : FUNC diff --git a/frameworks/native/bluetoothclient/audio_bluetooth_manager.cpp b/frameworks/native/bluetoothclient/audio_bluetooth_manager.cpp index fd70117fd1ee837aece7cf0b005cca62cc243d58..2fdf5192e5ee787391eb536eb30c73cd411736dd 100644 --- a/frameworks/native/bluetoothclient/audio_bluetooth_manager.cpp +++ b/frameworks/native/bluetoothclient/audio_bluetooth_manager.cpp @@ -46,8 +46,7 @@ std::atomic AudioHfpManager::scene_ = AUDIO_SCENE_DEFAULT; BluetoothRemoteDevice AudioHfpManager::activeHfpDevice_; std::atomic AudioHfpManager::isRecognitionScene_ = false; std::atomic AudioHfpManager::isRecordScene_ = false; -std::map AudioHfpManager::virtualCalls_; -std::map> AudioHfpManager::virtualCallStreams_; +std::map AudioHfpManager::virtualCalls_; std::mutex AudioHfpManager::virtualCallMutex_; std::vector> AudioA2dpManager::a2dpPlayingStateChangedListeners_; std::mutex g_activehfpDeviceLock; @@ -600,83 +599,29 @@ bool AudioHfpManager::IsRecognitionStatus() return BluetoothScoManager::GetInstance().IsInScoCategory(ScoCategory::SCO_RECOGNITION); } -int32_t AudioHfpManager::SetVirtualCall(const std::string &name, const bool isVirtual) +int32_t AudioHfpManager::SetVirtualCall(pid_t uid, const bool isVirtual) { { - CHECK_AND_RETURN_RET(virtualCalls_[name] != isVirtual, SUCCESS); std::lock_guard hfpDeviceLock(virtualCallMutex_); - virtualCalls_[name] = isVirtual; - } - - AUDIO_INFO_LOG("set virtual call %{public}d by service %{public}s", isVirtual, name.c_str()); - return TryUpdateScoCategory(); -} - -int32_t AudioHfpManager::AddVirtualCallBundleName(const std::string &name, int32_t streamId) -{ - { - std::lock_guard hfpDeviceLock(virtualCallMutex_); - if (virtualCallStreams_.find(name) == virtualCallStreams_.end()) { - std::list streamIds; - streamIds.push_back(streamId); - virtualCallStreams_[name] = streamIds; + if (isVirtual) { + if (virtualCalls_.count(uid) > 0) { + virtualCalls_.erase(uid); + } } else { - virtualCallStreams_[name].push_back(streamId); + virtualCalls_[uid] = isVirtual; } - AUDIO_INFO_LOG("add virtual call bundlename %{public}s streamId %{public}d size %{public}zu", - name.c_str(), streamId, virtualCallStreams_[name].size()); } + AUDIO_INFO_LOG("set virtual call %{public}d by service %{public}d", isVirtual, uid); return TryUpdateScoCategory(); } -void AudioHfpManager::DeleteVirtualCallStream(int32_t streamId) -{ - { - std::lock_guard hfpDeviceLock(virtualCallMutex_); - std::string bundleName; - for (auto &stream : virtualCallStreams_) { - bool found = false; - for (auto it = stream.second.begin(); it != stream.second.end();) { - if (*it == streamId) { - found = true; - stream.second.erase(it); - break; - } - it++; - } - if (found) { - bundleName = stream.first; - break; - } - } - if (bundleName.empty()) { - AUDIO_WARNING_LOG("not found bundle name %{public}s", bundleName.c_str()); - return; - } - - AUDIO_INFO_LOG("del virtual call name %{public}s streamId %{public}d size %{public}zu", - bundleName.c_str(), streamId, virtualCallStreams_[bundleName].size()); - if (virtualCallStreams_[bundleName].size() == 0) { - virtualCallStreams_.erase(bundleName); - } - } - - TryUpdateScoCategory(); -} - bool AudioHfpManager::IsVirtualCall() { std::lock_guard hfpDeviceLock(virtualCallMutex_); - for (const auto &it : virtualCallStreams_) { - if (virtualCalls_.find(it.first) != virtualCalls_.end()) { - AUDIO_INFO_LOG("not virtual call for service %{public}s", it.first.c_str()); - return false; - } - std::string suffix = "meetimeservice"; - if (std::mismatch(suffix.rbegin(), suffix.rend(), it.first.rbegin()).first == - suffix.rend()) { - AUDIO_INFO_LOG("not virtual call for service %{public}s", it.first.c_str()); + for (const auto &it : virtualCalls_) { + if (!it.second) { + AUDIO_INFO_LOG("not virtual call for service %{public}d", it.first); return false; } } diff --git a/frameworks/native/bluetoothclient/audio_bluetooth_manager.h b/frameworks/native/bluetoothclient/audio_bluetooth_manager.h index 15910391639f7a20509b5fc5ffe0d65e251f1fb3..10a8cbf5799b7dc1c50a2daddf75363b1d64af22 100644 --- a/frameworks/native/bluetoothclient/audio_bluetooth_manager.h +++ b/frameworks/native/bluetoothclient/audio_bluetooth_manager.h @@ -143,9 +143,7 @@ public: static int32_t UpdateAudioScene(AudioStandard::AudioScene scene); static int32_t HandleScoWithRecongnition(bool handleFlag); static bool IsRecognitionStatus(); - static int32_t SetVirtualCall(const std::string &name, const bool isVirtual); - static int32_t AddVirtualCallBundleName(const std::string &name, int32_t streamId); - static void DeleteVirtualCallStream(int32_t streamId); + static int32_t SetVirtualCall(pid_t uid, const bool isVirtual); static bool IsVirtualCall(); static bool IsAudioScoStateConnect(); static std::string GetAudioScoDeviceMac(); @@ -164,8 +162,7 @@ private: static BluetoothRemoteDevice activeHfpDevice_; static std::atomic isRecognitionScene_; static std::atomic isRecordScene_; - static std::map virtualCalls_; - static std::map> virtualCallStreams_; + static std::map virtualCalls_; static std::mutex virtualCallMutex_; }; } diff --git a/frameworks/native/bluetoothclient/libaudio_bluetooth_client.versionscript b/frameworks/native/bluetoothclient/libaudio_bluetooth_client.versionscript index b79361b892550cadba178ca7387dbf1e061569b5..c35424109e0e6ff645d14f160ec08fe453785a66 100644 --- a/frameworks/native/bluetoothclient/libaudio_bluetooth_client.versionscript +++ b/frameworks/native/bluetoothclient/libaudio_bluetooth_client.versionscript @@ -44,8 +44,6 @@ *DisconnectBluetoothA2dpSource*; *UpdateAudioScene*; *SetVirtualCall*; - *AddVirtualCallBundleName*; - *DeleteVirtualCallStream*; *IsVirtualCall*; *GetAudioScoDeviceMac*; local: diff --git a/frameworks/native/bluetoothclient/test/bluetooth_hfp_manager_test.cpp b/frameworks/native/bluetoothclient/test/bluetooth_hfp_manager_test.cpp index de09f183ac6040d5a5da128387a14508493f2442..dfae106e0ca4b14b6b96934a8000507834abcd5e 100644 --- a/frameworks/native/bluetoothclient/test/bluetooth_hfp_manager_test.cpp +++ b/frameworks/native/bluetoothclient/test/bluetooth_hfp_manager_test.cpp @@ -59,7 +59,6 @@ public: AudioHfpManager::isRecognitionScene_.store(false); AudioHfpManager::isRecordScene_.store(false); AudioHfpManager::virtualCalls_.clear(); - AudioHfpManager::virtualCallStreams_.clear(); AudioHfpManager::activeHfpDevice_ = BluetoothRemoteDevice(); } }; @@ -201,25 +200,18 @@ HWTEST_F(BluetoothHfpManagerTest, BluetoothHfpManagerTest_006, TestSize.Level1) AudioHfpManager::scene_ = AUDIO_SCENE_PHONE_CHAT; AudioHfpManager::activeHfpDevice_ = BluetoothRemoteDevice(HFP_DEVICE_MAC2); - AudioHfpManager::SetVirtualCall(TEST_VIRTUAL_CALL_BUNDLE_NAME, false); + AudioHfpManager::SetVirtualCall(0, false); EXPECT_EQ(BluetoothScoManager::GetInstance().GetAudioScoState(), AudioScoState::CONNECTING); - EXPECT_EQ(BluetoothScoManager::GetInstance().IsInScoCategory(ScoCategory::SCO_VIRTUAL), true); + EXPECT_EQ(BluetoothScoManager::GetInstance().IsInScoCategory(ScoCategory::SCO_CALLULAR), true); BluetoothScoManager::GetInstance().UpdateScoState(HfpScoConnectState::SCO_CONNECTED, AudioHfpManager::activeHfpDevice_); EXPECT_EQ(BluetoothScoManager::GetInstance().GetAudioScoState(), AudioScoState::CONNECTED); - AudioHfpManager::AddVirtualCallBundleName(TEST_VIRTUAL_CALL_BUNDLE_NAME, 1); + AudioHfpManager::SetVirtualCall(0, true); EXPECT_EQ(BluetoothScoManager::GetInstance().GetAudioScoState(), AudioScoState::DISCONNECTING); BluetoothScoManager::GetInstance().UpdateScoState(HfpScoConnectState::SCO_DISCONNECTED, AudioHfpManager::activeHfpDevice_); - EXPECT_EQ(BluetoothScoManager::GetInstance().GetAudioScoState(), AudioScoState::CONNECTING); - BluetoothScoManager::GetInstance().UpdateScoState(HfpScoConnectState::SCO_CONNECTED, - AudioHfpManager::activeHfpDevice_); - EXPECT_EQ(BluetoothScoManager::GetInstance().GetAudioScoState(), AudioScoState::CONNECTED); - EXPECT_EQ(BluetoothScoManager::GetInstance().IsInScoCategory(ScoCategory::SCO_CALLULAR), true); - - AudioHfpManager::DeleteVirtualCallStream(1); - EXPECT_EQ(BluetoothScoManager::GetInstance().GetAudioScoState(), AudioScoState::DISCONNECTING); + EXPECT_EQ(BluetoothScoManager::GetInstance().IsInScoCategory(ScoCategory::SCO_VIRTUAL), true); } } // namespace Bluetooth } // namespace OHOS \ No newline at end of file diff --git a/frameworks/native/hdiadapter_new/BUILD.gn b/frameworks/native/hdiadapter_new/BUILD.gn index 7bc564b5708ce20b15d023963fe7378a4ea6fd5d..de68690665171224d7c038e702947e1ee5220306 100644 --- a/frameworks/native/hdiadapter_new/BUILD.gn +++ b/frameworks/native/hdiadapter_new/BUILD.gn @@ -172,6 +172,7 @@ ohos_unittest("hdiadapter_unit_test") { "../../../interfaces/inner_api/native/audiocommon/include", "../audioutils/include", "../../../frameworks/native/hdiadapter_new/include/sink", + "../../../frameworks/native/audioclock/include", ] sources = [ diff --git a/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h b/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h index ebb1d978f0404f11064c77515724bffeb2ced459..5cf02a315e85a2bd47e09d4a0e26d8c8d460801d 100644 --- a/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h +++ b/frameworks/native/hdiadapter_new/include/common/hdi_adapter_info.h @@ -38,6 +38,7 @@ enum HdiIdType : uint32_t { HDI_ID_TYPE_MULTICHANNEL, HDI_ID_TYPE_WAKEUP, HDI_ID_TYPE_ACCESSORY, + HDI_ID_TYPE_AI, HDI_ID_TYPE_NUM, }; diff --git a/frameworks/native/hdiadapter_new/include/common/hdi_adapter_type.h b/frameworks/native/hdiadapter_new/include/common/hdi_adapter_type.h index 454c60becf001b6f1d7725546ed2809af8c54bce..40a4fa5f1f94de2e646d49b320f6872120e14f0c 100644 --- a/frameworks/native/hdiadapter_new/include/common/hdi_adapter_type.h +++ b/frameworks/native/hdiadapter_new/include/common/hdi_adapter_type.h @@ -98,6 +98,7 @@ typedef struct IAudioSourceAttr : public Parcelable { AudioSampleFormat formatEc = AudioSampleFormat::INVALID_WIDTH; uint32_t sampleRateEc = 0; uint32_t channelEc = 0; + std::string hdiSourceType = "AUDIO_INPUT_DEFAULT_TYPE"; bool Marshalling(Parcel &parcel) const override { @@ -118,7 +119,8 @@ typedef struct IAudioSourceAttr : public Parcelable { parcel.WriteBool(hasEcConfig) && parcel.WriteUint8(static_cast(formatEc)) && parcel.WriteUint32(sampleRateEc) && - parcel.WriteUint32(channelEc); + parcel.WriteUint32(channelEc) && + parcel.WriteString(hdiSourceType); } static IAudioSourceAttr *Unmarshalling(Parcel &parcel) @@ -146,6 +148,7 @@ typedef struct IAudioSourceAttr : public Parcelable { attr->formatEc = static_cast(parcel.ReadUint8()); attr->sampleRateEc = parcel.ReadUint32(); attr->channelEc = parcel.ReadUint32(); + attr->hdiSourceType = parcel.ReadString(); return attr; } } IAudioSourceAttr; diff --git a/frameworks/native/hdiadapter_new/include/sink/audio_render_sink.h b/frameworks/native/hdiadapter_new/include/sink/audio_render_sink.h index b0e3ac50f129ebda3cd92d632c3906a55905ea63..69d5c4a19dbde219647ed003d1427b9c35488fb0 100644 --- a/frameworks/native/hdiadapter_new/include/sink/audio_render_sink.h +++ b/frameworks/native/hdiadapter_new/include/sink/audio_render_sink.h @@ -86,6 +86,9 @@ public: void SetDmDeviceType(uint16_t dmDeviceType, DeviceType deviceType) override; + void RegisterCurrentDeviceCallback(const std::function &callback) override; + void HandleDeviceCallback(const bool state); + private: static uint32_t PcmFormatToBit(AudioSampleFormat format); static AudioFormat ConvertToHdiFormat(AudioSampleFormat format); @@ -195,6 +198,7 @@ private: std::mutex dataConnectionMutex_; bool isDataLinkConnected_ = false; std::condition_variable dataConnectionCV_; + std::function deviceCallback_ = nullptr; }; } // namespace AudioStandard diff --git a/frameworks/native/hdiadapter_new/include/sink/i_audio_render_sink.h b/frameworks/native/hdiadapter_new/include/sink/i_audio_render_sink.h index fe21e1714cb06496d8896a4263943a103ba958ad..2cebc0396d3c5eae2131e28f4a6f6208c6ac5c94 100644 --- a/frameworks/native/hdiadapter_new/include/sink/i_audio_render_sink.h +++ b/frameworks/native/hdiadapter_new/include/sink/i_audio_render_sink.h @@ -112,8 +112,8 @@ public: virtual int32_t UnLockOffloadRunningLock(void) NOT_SUPPORT_RET // remote extend function - virtual int32_t SplitRenderFrame(char &data, uint64_t len, uint64_t &writeLen, const char *streamType) \ - NOT_SUPPORT_RET + virtual int32_t SplitRenderFrame(char &data, uint64_t len, uint64_t &writeLen, const char *streamType, + const char *audioStreamType = nullptr) NOT_SUPPORT_RET // primary extend function virtual int32_t SetDeviceConnectedFlag(bool flag) NOT_SUPPORT_RET @@ -131,6 +131,8 @@ public: } virtual void SetDmDeviceType(uint16_t dmDeviceType, DeviceType deviceType) {} + + virtual void RegisterCurrentDeviceCallback(const std::function &callback) {} }; } // namespace AudioStandard diff --git a/frameworks/native/hdiadapter_new/include/sink/remote_audio_render_sink.h b/frameworks/native/hdiadapter_new/include/sink/remote_audio_render_sink.h index 205bfd19a6577c9db9482dbfb0ebf50867c96fb2..a157497beb37fe857c0ccdfcd959a333571fb530 100644 --- a/frameworks/native/hdiadapter_new/include/sink/remote_audio_render_sink.h +++ b/frameworks/native/hdiadapter_new/include/sink/remote_audio_render_sink.h @@ -89,7 +89,8 @@ public: int32_t UpdateAppsUid(const int32_t appsUid[MAX_MIX_CHANNELS], const size_t size) final; int32_t UpdateAppsUid(const std::vector &appsUid) final; - int32_t SplitRenderFrame(char &data, uint64_t len, uint64_t &writeLen, const char *streamType) override; + int32_t SplitRenderFrame(char &data, uint64_t len, uint64_t &writeLen, const char *streamType, + const char *audioStreamType) override; void DumpInfo(std::string &dumpString) override; @@ -99,6 +100,7 @@ public: void SetDmDeviceType(uint16_t dmDeviceType, DeviceType deviceType) override; private: + int8_t ConvertStr2Int(const char *str); static RemoteAudioFormat ConvertToHdiFormat(AudioSampleFormat format); static RemoteAudioCategory GetAudioCategory(AudioScene audioScene); void InitSplitStream(const char *splitStreamStr, std::vector &splitStreamVector); @@ -107,7 +109,8 @@ private: int32_t CreateRender(RemoteAudioCategory type); int32_t DoSetOutputRoute(void); void CheckUpdateState(char *data, uint64_t len); - int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen, RemoteAudioCategory type); + int32_t RenderFrame(char &data, uint64_t len, uint64_t &writeLen, RemoteAudioCategory type, + bool isSplitFrame = false, const char *audioStreamType = nullptr); void JoinStartThread(); diff --git a/frameworks/native/hdiadapter_new/include/sink/remote_offload_audio_render_sink.h b/frameworks/native/hdiadapter_new/include/sink/remote_offload_audio_render_sink.h index 209bc8543ce1b4d373d40c6b5cef77b362fc5e88..a932e74244fcc9e515aba84aabae23fb393c87cb 100644 --- a/frameworks/native/hdiadapter_new/include/sink/remote_offload_audio_render_sink.h +++ b/frameworks/native/hdiadapter_new/include/sink/remote_offload_audio_render_sink.h @@ -137,8 +137,8 @@ private: int32_t SetVolumeInner(float left, float right); void UpdateSinkState(bool started); int32_t GetRenderPositionInner(); - void AddHdiLatency(uint32_t duration); - void RemoveHdiLatency(uint32_t duration); + void AddHdiLatency(uint64_t duration); + void RemoveHdiLatency(uint64_t duration); void CheckHdiTime(int64_t &timeSec, int64_t &timeNanoSec); int32_t GetLatencyInner(); void CalcHdiPosition(uint64_t frames, int64_t timeSec, int64_t timeNanoSec); @@ -205,11 +205,11 @@ private: // Audio playback rate float speed_ = 1.0f; // Delay queue: pair - std::deque> realLatencyDeque_; + std::deque> realLatencyDeque_; // Delay queue real length - uint32_t realLatencyTotalUS_ = 0; + uint64_t realLatencyTotalUS_ = 0; // remote offload hdi latency (us) - uint32_t hdiLatencyUS_ = 0; + uint64_t hdiLatencyUS_ = 0; // The timestamp (in microseconds) of the last HDI flush operation for frames (before scaling to one times speed) uint64_t lastHdiFlushFramesUS_ = 0; // The timestamp (in microseconds) of the last HDI flush operation for frames (after scaling to one times speed) diff --git a/frameworks/native/hdiadapter_new/include/source/audio_capture_source.h b/frameworks/native/hdiadapter_new/include/source/audio_capture_source.h index 1be0c01f724ad954e656492f833cedf2b2ed7b57..140390d8c761186e0b2cbe356bf6e2661321909d 100644 --- a/frameworks/native/hdiadapter_new/include/source/audio_capture_source.h +++ b/frameworks/native/hdiadapter_new/include/source/audio_capture_source.h @@ -80,7 +80,8 @@ public: private: static AudioFormat ConvertToHdiFormat(AudioSampleFormat format); static uint64_t GetChannelLayoutByChannelCount(uint32_t channelCount); - static enum AudioInputType ConvertToHDIAudioInputType(int32_t sourceType); + static uint64_t GetChannelCountByChannelLayout(uint64_t channelLayout); + static enum AudioInputType ConvertToHDIAudioInputType(int32_t sourceType, std::string hdiSourceType); static AudioSampleFormat ParseAudioFormat(const std::string &format); static AudioCategory GetAudioCategory(AudioScene audioScene); static int32_t GetByteSizeByFormat(AudioSampleFormat format); @@ -111,6 +112,7 @@ private: void InitRunningLock(void); void CheckAcousticEchoCancelerSupported(int32_t sourcetype, int32_t &hdiAudioInputType); bool IsCaptureInvalid(void) override; + static AudioInputType MappingAudioInputType(std::string hdiSourceType); private: static constexpr uint32_t AUDIO_CHANNELCOUNT = 2; @@ -175,6 +177,7 @@ private: std::unordered_map dmDeviceTypeMap_; std::shared_ptr audioSrcClock_ = nullptr; + static const std::unordered_map audioInputTypeMap_; }; } // namespace AudioStandard diff --git a/frameworks/native/hdiadapter_new/include/source/fast_audio_capture_source.h b/frameworks/native/hdiadapter_new/include/source/fast_audio_capture_source.h index 5d1f5e1c36187ac02b093a2b426823af7feb0344..52b65ab93486bbdd3aac3d5d7c0a0ceac8911af7 100644 --- a/frameworks/native/hdiadapter_new/include/source/fast_audio_capture_source.h +++ b/frameworks/native/hdiadapter_new/include/source/fast_audio_capture_source.h @@ -85,6 +85,7 @@ private: // low latency int32_t PrepareMmapBuffer(void); int32_t CheckPositionTime(void); + int32_t StopInner(); private: static constexpr uint32_t AUDIO_CHANNELCOUNT = 2; diff --git a/frameworks/native/hdiadapter_new/manager/hdi_adapter_factory.cpp b/frameworks/native/hdiadapter_new/manager/hdi_adapter_factory.cpp index 4a9997cf4bffcc4122cd53b9e9aef45532bfcb6b..86849b3aaf9846d5f7d15bd81240adfa10a822fe 100644 --- a/frameworks/native/hdiadapter_new/manager/hdi_adapter_factory.cpp +++ b/frameworks/native/hdiadapter_new/manager/hdi_adapter_factory.cpp @@ -115,6 +115,7 @@ std::shared_ptr HdiAdapterFactory::CreateCaptureSource(uint switch (type) { case HDI_ID_TYPE_PRIMARY: case HDI_ID_TYPE_ACCESSORY: + case HDI_ID_TYPE_AI: source = CreatePrimaryCaptureSource(captureId, info); break; case HDI_ID_TYPE_BLUETOOTH: @@ -210,6 +211,7 @@ std::shared_ptr HdiAdapterFactory::CreateRemoteOffloadRenderSi std::shared_ptr HdiAdapterFactory::CreatePrimaryCaptureSource(const uint32_t captureId, const std::string &info) { + AUDIO_INFO_LOG("info: %{public}s", info.c_str()); if (info == HDI_ID_INFO_USB || info == HDI_ID_INFO_ACCESSORY) { return std::make_shared(captureId, info); } diff --git a/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp b/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp index 6f1d8036a68a5e6f685adfeda594823522140bd4..3f84d2d837b66eea811e307ef8f2f96006c00d6f 100644 --- a/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp +++ b/frameworks/native/hdiadapter_new/manager/hdi_adapter_manager.cpp @@ -77,12 +77,11 @@ uint32_t HdiAdapterManager::GetId(HdiIdBase base, HdiIdType type, const std::str { uint32_t id = IdHandler::GetInstance().GetId(base, type, info); CHECK_AND_RETURN_RET(id != HDI_INVALID_ID, HDI_INVALID_ID); - CHECK_AND_RETURN_RET(isResident, id); - std::unique_lock renderLock(renderSinkMtx_); - std::unique_lock captureLock(captureSourceMtx_); + std::scoped_lock lock(renderSinkMtx_, captureSourceMtx_); if (renderSinks_.count(id) == 0 && captureSources_.count(id) == 0) { IdHandler::GetInstance().IncInfoIdUseCount(id); } + CHECK_AND_RETURN_RET(isResident, id); AUDIO_INFO_LOG("base: %{public}u, type: %{public}u, info: %{public}s, id: %{public}u", base, type, info.c_str(), id); IncRefCount(id); @@ -96,12 +95,11 @@ uint32_t HdiAdapterManager::GetRenderIdByDeviceClass(const std::string &deviceCl AUDIO_INFO_LOG("Device class: %{public}s, info: %{public}s, id: %{public}u", deviceClass.c_str(), info.c_str(), id); CHECK_AND_RETURN_RET(id != HDI_INVALID_ID, HDI_INVALID_ID); - CHECK_AND_RETURN_RET(isResident, id); - std::unique_lock renderLock(renderSinkMtx_); - std::unique_lock captureLock(captureSourceMtx_); + std::scoped_lock lock(renderSinkMtx_, captureSourceMtx_); if (renderSinks_.count(id) == 0 && captureSources_.count(id) == 0) { IdHandler::GetInstance().IncInfoIdUseCount(id); } + CHECK_AND_RETURN_RET(isResident, id); IncRefCount(id); return id; } @@ -113,12 +111,11 @@ uint32_t HdiAdapterManager::GetCaptureIdByDeviceClass(const std::string &deviceC AUDIO_INFO_LOG("Device class: %{public}s, sourceType: %{public}d, info: %{public}s, id: %{public}u", deviceClass.c_str(), sourceType, info.c_str(), id); CHECK_AND_RETURN_RET(id != HDI_INVALID_ID, HDI_INVALID_ID); - CHECK_AND_RETURN_RET(isResident, id); - std::unique_lock renderLock(renderSinkMtx_); - std::unique_lock captureLock(captureSourceMtx_); + std::scoped_lock lock(renderSinkMtx_, captureSourceMtx_); if (renderSinks_.count(id) == 0 && captureSources_.count(id) == 0) { IdHandler::GetInstance().IncInfoIdUseCount(id); } + CHECK_AND_RETURN_RET(isResident, id); IncRefCount(id); return id; } @@ -127,8 +124,7 @@ void HdiAdapterManager::ReleaseId(uint32_t &id) { uint32_t tempId = id; id = HDI_INVALID_ID; - std::unique_lock renderLock(renderSinkMtx_); - std::unique_lock captureLock(captureSourceMtx_); + std::scoped_lock lock(renderSinkMtx_, captureSourceMtx_); CHECK_AND_RETURN(tempId != HDI_INVALID_ID && (renderSinks_.count(tempId) || captureSources_.count(tempId))); DecRefCount(tempId); } diff --git a/frameworks/native/hdiadapter_new/sink/audio_render_sink.cpp b/frameworks/native/hdiadapter_new/sink/audio_render_sink.cpp index 19cc8e44da7790b09b7199d77b01cd7ada937961..f2e493751c8444d5b82ebecf05a177de431bdd01 100644 --- a/frameworks/native/hdiadapter_new/sink/audio_render_sink.cpp +++ b/frameworks/native/hdiadapter_new/sink/audio_render_sink.cpp @@ -528,9 +528,26 @@ int32_t AudioRenderSink::UpdateActiveDevice(std::vector &outputDevic currentActiveDevice_ = outputDevices[0]; currentDevicesSize_ = static_cast(outputDevices.size()); SetAudioRouteInfoForEnhanceChain(); + bool isA2dp = false; + if (currentActiveDevice_ == DEVICE_TYPE_BLUETOOTH_SCO || currentActiveDevice_ == DEVICE_TYPE_BLUETOOTH_A2DP) { + isA2dp = true; + } + HandleDeviceCallback(isA2dp); return DoSetOutputRoute(outputDevices); } +void AudioRenderSink::RegisterCurrentDeviceCallback(const std::function &callback) +{ + deviceCallback_ = callback; +} + +void AudioRenderSink::HandleDeviceCallback(const bool state) +{ + if (deviceCallback_ != nullptr) { + deviceCallback_(state); + } +} + void AudioRenderSink::RegistCallback(uint32_t type, IAudioSinkCallback *callback) { std::lock_guard lock(sinkMutex_); diff --git a/frameworks/native/hdiadapter_new/sink/remote_audio_render_sink.cpp b/frameworks/native/hdiadapter_new/sink/remote_audio_render_sink.cpp index a03ce94a2690517902b52ecedb866256cf389510..8eeb90e6fbd77249dbfc397141e82759c008f439 100644 --- a/frameworks/native/hdiadapter_new/sink/remote_audio_render_sink.cpp +++ b/frameworks/native/hdiadapter_new/sink/remote_audio_render_sink.cpp @@ -41,6 +41,9 @@ const std::unordered_map RemoteAudioRenderSink::SPLI { std::string(COMMUNICATION_STREAM_TYPE), AudioCategory::AUDIO_IN_COMMUNICATION }, }; +const int8_t SPLIT_FLAG = 1; // flag indicates support split stream +const int8_t NOSPLIT_FLAG = 0; + RemoteAudioRenderSink::RemoteAudioRenderSink(const std::string &deviceNetworkId) : deviceNetworkId_(deviceNetworkId) { @@ -458,13 +461,14 @@ int32_t RemoteAudioRenderSink::UpdateAppsUid(const std::vector &appsUid return ERR_NOT_SUPPORTED; } -int32_t RemoteAudioRenderSink::SplitRenderFrame(char &data, uint64_t len, uint64_t &writeLen, const char *streamType) +int32_t RemoteAudioRenderSink::SplitRenderFrame(char &data, uint64_t len, uint64_t &writeLen, const char *streamType, + const char *audioStreamType) { Trace trace("RemoteAudioRenderSink::SplitRenderFrame"); AUDIO_DEBUG_LOG("in, type: %{public}s", streamType); auto it = SPLIT_STREAM_MAP.find(streamType); CHECK_AND_RETURN_RET_LOG(it != SPLIT_STREAM_MAP.end(), ERR_INVALID_PARAM, "invalid stream type"); - return RenderFrame(data, len, writeLen, it->second); + return RenderFrame(data, len, writeLen, it->second, true, audioStreamType); } void RemoteAudioRenderSink::DumpInfo(std::string &dumpString) @@ -653,7 +657,22 @@ void RemoteAudioRenderSink::CheckUpdateState(char *data, uint64_t len) } } -int32_t RemoteAudioRenderSink::RenderFrame(char &data, uint64_t len, uint64_t &writeLen, AudioCategory type) +int8_t RemoteAudioRenderSink::ConvertStr2Int(const char *str) +{ + if (str == nullptr) { + AUDIO_ERR_LOG("str is null"); + return 0; + } + int8_t streamType = std::stoi(str); + if (streamType < INT8_MIN || streamType > INT8_MAX) { + AUDIO_ERR_LOG("Invalid str: %{public}s", str); + return 0; + } + return streamType; +} + +int32_t RemoteAudioRenderSink::RenderFrame(char &data, uint64_t len, uint64_t &writeLen, AudioCategory type, + bool isSplitFrame, const char *audioStreamType) { CHECK_AND_RETURN_RET_LOG(renderInited_.load(), ERR_ILLEGAL_STATE, "not create, invalid state"); AUDIO_DEBUG_LOG("type: %{public}d", type); @@ -666,8 +685,19 @@ int32_t RemoteAudioRenderSink::RenderFrame(char &data, uint64_t len, uint64_t &w } std::vector bufferVec(len); - int32_t ret = memcpy_s(bufferVec.data(), len, &data, len); - CHECK_AND_RETURN_RET_LOG(ret == EOK, ERR_OPERATION_FAILED, "copy fail, error code: %{public}d", ret); + int32_t ret = ERROR; + if (isSplitFrame) { + CHECK_AND_RETURN_RET_LOG(audioStreamType != nullptr, ERR_INVALID_HANDLE, "audioStreamType is nullptr"); + int8_t streamType = ConvertStr2Int(audioStreamType); + ret = memcpy_s(bufferVec.data(), len, &data, len); + CHECK_AND_RETURN_RET_LOG(ret == EOK, ERR_OPERATION_FAILED, "copy fail, error code: %{public}d", ret); + bufferVec.push_back(streamType); + bufferVec.push_back(SPLIT_FLAG); + } else { + ret = memcpy_s(bufferVec.data(), len, &data, len); + CHECK_AND_RETURN_RET_LOG(ret == EOK, ERR_OPERATION_FAILED, "copy fail, error code: %{public}d", ret); + bufferVec.push_back(NOSPLIT_FLAG); + } BufferDesc buffer = { reinterpret_cast(&data), len, len }; AudioStreamInfo streamInfo(static_cast(attr_.sampleRate), AudioEncodingType::ENCODING_PCM, diff --git a/frameworks/native/hdiadapter_new/sink/remote_offload_audio_render_sink.cpp b/frameworks/native/hdiadapter_new/sink/remote_offload_audio_render_sink.cpp index 13056105b7c9b28c206da4119b1b25409a6eadcc..daf723be947cb2f9a19bf9a75dc51e83c50d0475 100644 --- a/frameworks/native/hdiadapter_new/sink/remote_offload_audio_render_sink.cpp +++ b/frameworks/native/hdiadapter_new/sink/remote_offload_audio_render_sink.cpp @@ -357,7 +357,7 @@ int32_t RemoteOffloadAudioRenderSink::GetHdiLatency(uint32_t &latency) } latency = hdiLatencyUS_; - AUDIO_DEBUG_LOG("RemoteOffloadAudioRenderSink::GetHdiLatency hdiLatencyUS_ %{public}u", hdiLatencyUS_); + AUDIO_DEBUG_LOG("RemoteOffloadAudioRenderSink::GetHdiLatency hdiLatencyUS_ %{public}" PRIu64, hdiLatencyUS_); return SUCCESS; } @@ -590,9 +590,9 @@ void RemoteOffloadAudioRenderSink::CalcHdiPosition(uint64_t frames, int64_t time lastHdiTimeNanoSec_ = timeNanoSec; } -void RemoteOffloadAudioRenderSink::RemoveHdiLatency(uint32_t duration) +void RemoteOffloadAudioRenderSink::RemoveHdiLatency(uint64_t duration) { - AUDIO_INFO_LOG("RemoteOffloadAudioRenderSink::RemoveHdiLatency duration: %{public}u", duration); + AUDIO_INFO_LOG("RemoteOffloadAudioRenderSink::RemoveHdiLatency duration: %{public}" PRId64, duration); if (realLatencyTotalUS_ <= duration) { realLatencyTotalUS_ = 0; realLatencyDeque_.clear(); @@ -610,18 +610,18 @@ void RemoteOffloadAudioRenderSink::RemoveHdiLatency(uint32_t duration) duration = 0; } } - AUDIO_INFO_LOG("RemoteOffloadAudioRenderSink::RemoveHdiLatency realLatencyTotalUS_: %{public}u", + AUDIO_INFO_LOG("RemoteOffloadAudioRenderSink::RemoveHdiLatency realLatencyTotalUS_: %{public}" PRId64, realLatencyTotalUS_); } -void RemoteOffloadAudioRenderSink::AddHdiLatency(uint32_t duration) +void RemoteOffloadAudioRenderSink::AddHdiLatency(uint64_t duration) { - AUDIO_DEBUG_LOG("RemoteOffloadAudioRenderSink::AddHdiLatency duration: %{public}u, speed: %{public}f", - duration, speed_); + AUDIO_DEBUG_LOG("RemoteOffloadAudioRenderSink::AddHdiLatency duration: %{public}" PRId64 + ", speed: %{public}f", duration, speed_); realLatencyTotalUS_ += duration; realLatencyDeque_.push_front({duration, speed_}); - uint32_t maxDequeLengthUS = 1000000; + uint64_t maxDequeLengthUS = 1000000; // If the total length exceeds 1,000,000 microseconds. // clear the end of the queue to ensure the maximum length remains at 1,000,000 microseconds. while (realLatencyTotalUS_ > maxDequeLengthUS) { @@ -629,12 +629,12 @@ void RemoteOffloadAudioRenderSink::AddHdiLatency(uint32_t duration) realLatencyTotalUS_ -= realLatencyDeque_.back().first; realLatencyDeque_.pop_back(); } else { - uint32_t excess = realLatencyTotalUS_ - maxDequeLengthUS; + uint64_t excess = realLatencyTotalUS_ - maxDequeLengthUS; realLatencyDeque_.back().first -= excess; realLatencyTotalUS_ -= excess; } } - AUDIO_DEBUG_LOG("RemoteOffloadAudioRenderSink::AddHdiLatency realLatencyTotalUS_: %{public}u", + AUDIO_DEBUG_LOG("RemoteOffloadAudioRenderSink::AddHdiLatency realLatencyTotalUS_: %{public}" PRId64, realLatencyTotalUS_); } diff --git a/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp b/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp index 3fd7f70fe83f7efea84e3f252fc8338948dcabae..4cf9082123cd65956224d4b17dec706804152bae 100644 --- a/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp +++ b/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp @@ -38,6 +38,47 @@ namespace OHOS { namespace AudioStandard { static constexpr uint32_t DECIMAL_BASE = 10; +static const std::unordered_map MAP_LAYOUT_TO_CHANNEL = { + {AudioChannelLayout::CH_LAYOUT_MONO, AudioChannel::MONO}, + {AudioChannelLayout::CH_LAYOUT_STEREO, AudioChannel::STEREO}, + {AudioChannelLayout::CH_LAYOUT_STEREO_DOWNMIX, AudioChannel::STEREO}, + {AudioChannelLayout::CH_LAYOUT_2POINT1, AudioChannel::CHANNEL_3}, + {AudioChannelLayout::CH_LAYOUT_3POINT0, AudioChannel::CHANNEL_3}, + {AudioChannelLayout::CH_LAYOUT_SURROUND, AudioChannel::CHANNEL_3}, + {AudioChannelLayout::CH_LAYOUT_3POINT1, AudioChannel::CHANNEL_4}, + {AudioChannelLayout::CH_LAYOUT_4POINT0, AudioChannel::CHANNEL_4}, + {AudioChannelLayout::CH_LAYOUT_QUAD_SIDE, AudioChannel::CHANNEL_4}, + {AudioChannelLayout::CH_LAYOUT_QUAD, AudioChannel::CHANNEL_4}, + {AudioChannelLayout::CH_LAYOUT_2POINT0POINT2, AudioChannel::CHANNEL_4}, + {AudioChannelLayout::CH_LAYOUT_4POINT1, AudioChannel::CHANNEL_5}, + {AudioChannelLayout::CH_LAYOUT_5POINT0, AudioChannel::CHANNEL_5}, + {AudioChannelLayout::CH_LAYOUT_5POINT0_BACK, AudioChannel::CHANNEL_5}, + {AudioChannelLayout::CH_LAYOUT_2POINT1POINT2, AudioChannel::CHANNEL_5}, + {AudioChannelLayout::CH_LAYOUT_3POINT0POINT2, AudioChannel::CHANNEL_5}, + {AudioChannelLayout::CH_LAYOUT_5POINT1, AudioChannel::CHANNEL_6}, + {AudioChannelLayout::CH_LAYOUT_5POINT1_BACK, AudioChannel::CHANNEL_6}, + {AudioChannelLayout::CH_LAYOUT_6POINT0, AudioChannel::CHANNEL_6}, + {AudioChannelLayout::CH_LAYOUT_HEXAGONAL, AudioChannel::CHANNEL_6}, + {AudioChannelLayout::CH_LAYOUT_3POINT1POINT2, AudioChannel::CHANNEL_6}, + {AudioChannelLayout::CH_LAYOUT_6POINT0_FRONT, AudioChannel::CHANNEL_6}, + {AudioChannelLayout::CH_LAYOUT_6POINT1, AudioChannel::CHANNEL_7}, + {AudioChannelLayout::CH_LAYOUT_6POINT1_BACK, AudioChannel::CHANNEL_7}, + {AudioChannelLayout::CH_LAYOUT_6POINT1_FRONT, AudioChannel::CHANNEL_7}, + {AudioChannelLayout::CH_LAYOUT_7POINT0, AudioChannel::CHANNEL_7}, + {AudioChannelLayout::CH_LAYOUT_7POINT0_FRONT, AudioChannel::CHANNEL_7}, + {AudioChannelLayout::CH_LAYOUT_7POINT1, AudioChannel::CHANNEL_8}, + {AudioChannelLayout::CH_LAYOUT_OCTAGONAL, AudioChannel::CHANNEL_8}, + {AudioChannelLayout::CH_LAYOUT_5POINT1POINT2, AudioChannel::CHANNEL_8}, + {AudioChannelLayout::CH_LAYOUT_7POINT1_WIDE, AudioChannel::CHANNEL_8}, + {AudioChannelLayout::CH_LAYOUT_7POINT1_WIDE_BACK, AudioChannel::CHANNEL_8}, + {AudioChannelLayout::CH_LAYOUT_5POINT1POINT4, AudioChannel::CHANNEL_10}, + {AudioChannelLayout::CH_LAYOUT_7POINT1POINT2, AudioChannel::CHANNEL_10}, + {AudioChannelLayout::CH_LAYOUT_7POINT1POINT4, AudioChannel::CHANNEL_12}, + {AudioChannelLayout::CH_LAYOUT_10POINT2, AudioChannel::CHANNEL_12}, + {AudioChannelLayout::CH_LAYOUT_9POINT1POINT4, AudioChannel::CHANNEL_14}, + {AudioChannelLayout::CH_LAYOUT_9POINT1POINT6, AudioChannel::CHANNEL_16}, + {AudioChannelLayout::CH_LAYOUT_HEXADECAGONAL, AudioChannel::CHANNEL_16}, +}; AudioCaptureSource::AudioCaptureSource(const uint32_t captureId, const std::string &halName) : captureId_(captureId), halName_(halName) @@ -606,8 +647,54 @@ uint64_t AudioCaptureSource::GetChannelLayoutByChannelCount(uint32_t channelCoun return channelLayout; } -enum AudioInputType AudioCaptureSource::ConvertToHDIAudioInputType(int32_t sourceType) + +uint64_t AudioCaptureSource::GetChannelCountByChannelLayout(uint64_t channelLayout) { + AudioChannel channel = AudioChannel::CHANNEL_UNKNOW; + AudioChannelLayout layout = static_cast(channelLayout); + if (MAP_LAYOUT_TO_CHANNEL.find(layout) != MAP_LAYOUT_TO_CHANNEL.end()) { + return static_cast(MAP_LAYOUT_TO_CHANNEL.at(layout)); + } + + return static_cast(channel); +} + +const std::unordered_map AudioCaptureSource::audioInputTypeMap_ = { + {"AUDIO_INPUT_MIC_TYPE", AUDIO_INPUT_MIC_TYPE}, + {"AUDIO_INPUT_SPEECH_WAKEUP_TYPE", AUDIO_INPUT_SPEECH_WAKEUP_TYPE}, + {"AUDIO_INPUT_VOICE_COMMUNICATION_TYPE", AUDIO_INPUT_VOICE_COMMUNICATION_TYPE}, + {"AUDIO_INPUT_VOICE_RECOGNITION_TYPE", AUDIO_INPUT_VOICE_RECOGNITION_TYPE}, + {"AUDIO_INPUT_VOICE_UPLINK_TYPE", AUDIO_INPUT_VOICE_UPLINK_TYPE}, + {"AUDIO_INPUT_VOICE_DOWNLINK_TYPE", AUDIO_INPUT_VOICE_DOWNLINK_TYPE}, + {"AUDIO_INPUT_VOICE_CALL_TYPE", AUDIO_INPUT_VOICE_CALL_TYPE}, + {"AUDIO_INPUT_EC_TYPE", AUDIO_INPUT_EC_TYPE}, + {"AUDIO_INPUT_NOISE_REDUCTION_TYPE", AUDIO_INPUT_NOISE_REDUCTION_TYPE}, + {"AUDIO_INPUT_RAW_TYPE", AUDIO_INPUT_RAW_TYPE}, + {"AUDIO_INPUT_LIVE_TYPE", AUDIO_INPUT_LIVE_TYPE}, + {"AUDIO_INPUT_VOICE_TRANSCRIPTION", AUDIO_INPUT_VOICE_TRANSCRIPTION} +}; + +AudioInputType AudioCaptureSource::MappingAudioInputType(std::string hdiSourceType) +{ + if (hdiSourceType != "AUDIO_INPUT_DEFAULT_TYPE") { + AUDIO_INFO_LOG("find hdisourceType: %{public}s", hdiSourceType.c_str()); + auto it = audioInputTypeMap_.find(hdiSourceType); + if (it != audioInputTypeMap_.end()) { + return it->second; + } else { + return AUDIO_INPUT_MIC_TYPE; + } + } + return AUDIO_INPUT_DEFAULT_TYPE; +} + +enum AudioInputType AudioCaptureSource::ConvertToHDIAudioInputType(int32_t sourceType, std::string hdiSourceType) +{ + AudioInputType hdiSource = MappingAudioInputType(hdiSourceType); + if (hdiSource != AUDIO_INPUT_DEFAULT_TYPE) { + return hdiSource; + } + enum AudioInputType hdiAudioInputType; switch (sourceType) { case SOURCE_TYPE_INVALID: @@ -757,6 +844,8 @@ uint32_t AudioCaptureSource::GetUniqueIdBySourceType(void) const return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_MIC_REF); case SOURCE_TYPE_WAKEUP: return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_WAKEUP); + case SOURCE_TYPE_VOICE_TRANSCRIPTION: + return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_VOICE_TRANSCRIPTION); default: return GenerateUniqueID(AUDIO_HDI_CAPTURE_ID_BASE, HDI_CAPTURE_OFFSET_PRIMARY); } @@ -806,7 +895,8 @@ void AudioCaptureSource::InitAudioSampleAttr(struct AudioSampleAttributes ¶m param.isBigEndian = attr_.isBigEndian; param.channelCount = attr_.channel; param.channelLayout = attr_.channelLayout; - if (param.channelLayout == CH_LAYOUT_UNKNOWN) { + if (GetChannelCountByChannelLayout(param.channelLayout) != param.channelCount) { + AUDIO_WARNING_LOG("channelLayout is ot suitable for channelCount, convert channel to channelLayout"); param.channelLayout = GetChannelLayoutByChannelCount(attr_.channel); } param.silenceThreshold = attr_.bufferSize; @@ -814,7 +904,7 @@ void AudioCaptureSource::InitAudioSampleAttr(struct AudioSampleAttributes ¶m if (param.frameSize != 0) { param.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (param.frameSize); } - param.sourceType = static_cast(ConvertToHDIAudioInputType(attr_.sourceType)); + param.sourceType = static_cast(ConvertToHDIAudioInputType(attr_.sourceType, attr_.hdiSourceType)); CheckAcousticEchoCancelerSupported(attr_.sourceType, param.sourceType); if ((attr_.hasEcConfig || attr_.sourceType == SOURCE_TYPE_EC) && attr_.channelEc != 0) { @@ -934,7 +1024,7 @@ int32_t AudioCaptureSource::DoSetInputRoute(DeviceType inputDevice) std::shared_ptr deviceManager = manager.GetDeviceManager(HDI_DEVICE_MANAGER_TYPE_LOCAL); CHECK_AND_RETURN_RET(deviceManager != nullptr, ERR_INVALID_HANDLE); int32_t streamId = static_cast(GetUniqueIdBySourceType()); - int32_t inputType = static_cast(ConvertToHDIAudioInputType(attr_.sourceType)); + int32_t inputType = static_cast(ConvertToHDIAudioInputType(attr_.sourceType, attr_.hdiSourceType)); CheckAcousticEchoCancelerSupported(attr_.sourceType, inputType); AUDIO_INFO_LOG("adapterName: %{public}s, inputDevice: %{public}d, streamId: %{public}d, inputType: %{public}d", attr_.adapterName.c_str(), inputDevice, streamId, inputType); @@ -1166,7 +1256,7 @@ int32_t AudioCaptureSource::SetAccessoryDeviceState(bool state) int32_t AudioCaptureSource::DoStop(void) { - AUDIO_INFO_LOG("halName: %{public}s", halName_.c_str()); + AUDIO_INFO_LOG("halName: %{public}s, sourcetype: %{public}d", halName_.c_str(), attr_.sourceType); Trace trace("AudioCaptureSource::DoStop"); if (IsNonblockingSource(adapterNameCase_)) { diff --git a/frameworks/native/hdiadapter_new/source/fast_audio_capture_source.cpp b/frameworks/native/hdiadapter_new/source/fast_audio_capture_source.cpp index 797a0297847705bf626c514f48c5d76222654022..e2a66130b02660aaab75ae3eb44d8a2e9328314b 100644 --- a/frameworks/native/hdiadapter_new/source/fast_audio_capture_source.cpp +++ b/frameworks/native/hdiadapter_new/source/fast_audio_capture_source.cpp @@ -55,7 +55,7 @@ void FastAudioCaptureSource::DeInit(void) isCheckPositionSuccess_.load()); std::lock_guard lock(statusMutex_); if (started_ || !isCheckPositionSuccess_) { - Stop(); + StopInner(); started_ = false; } sourceInited_ = false; @@ -116,6 +116,12 @@ ERR_RET: int32_t FastAudioCaptureSource::Stop(void) { std::lock_guard lock(statusMutex_); + return StopInner(); +} + + +int32_t FastAudioCaptureSource::StopInner() +{ AUDIO_INFO_LOG("in, isCheckPositionSuccess: %{public}d", isCheckPositionSuccess_.load()); #ifdef FEATURE_POWER_MANAGER diff --git a/frameworks/native/hdiadapter_new/test/unittest/sink/audio_render_sink_unit_test.cpp b/frameworks/native/hdiadapter_new/test/unittest/sink/audio_render_sink_unit_test.cpp index 849c6f4ced08133c8393b525eab5b01b77240fc0..9306138bad90ba8a4557101a1f00630d0faa02f9 100644 --- a/frameworks/native/hdiadapter_new/test/unittest/sink/audio_render_sink_unit_test.cpp +++ b/frameworks/native/hdiadapter_new/test/unittest/sink/audio_render_sink_unit_test.cpp @@ -314,6 +314,23 @@ HWTEST_F(AudioRenderSinkUnitTest, SetDmDeviceType_001, TestSize.Level1) DeInitPrimarySink(); } +/** + * @tc.name : Test RegisterCurrentDeviceType API + * @tc.number : RegisterCurrentDeviceType_001 + * @tc.desc : Test RegisterCurrentDeviceType + */ +HWTEST_F(AudioRenderSinkUnitTest, RegisterCurrentDeviceType_001, TestSize.Level1) +{ + InitPrimarySink(); + EXPECT_TRUE(primarySink_ && primarySink_->IsInited()); + std::function HandleDeviceCallback; + HandleDeviceCallback(true); + primarySink_->RegisterCurrentDeviceCallback(HandleDeviceCallback); + HandleDeviceCallback(false); + primarySink_->RegisterCurrentDeviceCallback(HandleDeviceCallback); + DeInitPrimarySink(); +} + /** * @tc.name : Test UsbSink API * @tc.number : UsbSinkUnitTest_001 diff --git a/frameworks/native/hdiadapter_new/test/unittest/source/audio_capture_source_unit_test.cpp b/frameworks/native/hdiadapter_new/test/unittest/source/audio_capture_source_unit_test.cpp index a40e03150a874467f0e7a0cf2c309d7b516b0118..0f31bff48bd27c21bedbd322e6966c8a0aa0df9e 100644 --- a/frameworks/native/hdiadapter_new/test/unittest/source/audio_capture_source_unit_test.cpp +++ b/frameworks/native/hdiadapter_new/test/unittest/source/audio_capture_source_unit_test.cpp @@ -19,6 +19,7 @@ #include "audio_utils.h" #include "common/hdi_adapter_info.h" #include "manager/hdi_adapter_manager.h" +#include "source/audio_capture_source.h" using namespace testing::ext; @@ -73,7 +74,7 @@ void AudioCaptureSourceUnitTest::InitPrimarySource() attr_.sampleRate = 48000; // 48000: sample rate attr_.channel = 2; // 2: channel attr_.format = SAMPLE_S16LE; - attr_.channelLayout = 3; // 3: channel layout + attr_.channelLayout = CH_LAYOUT_UNKNOWN; attr_.deviceType = DEVICE_TYPE_MIC; attr_.openMicSpeaker = 1; primarySource_->Init(attr_); @@ -309,17 +310,17 @@ HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_013, TestSize.Level1) } /** - * @tc.name : Test SetDmDeviceType API - * @tc.number : SetDmDeviceType_001 - * @tc.desc : Test SetDmDeviceType + * @tc.name : Test PrimarySource API + * @tc.number : PrimarySourceUnitTest_014 + * @tc.desc : Test primary source GetUniqueIdBySourceType */ -HWTEST_F(AudioCaptureSourceUnitTest, SetDmDeviceType_001, TestSize.Level1) +HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_014, TestSize.Level1) { InitPrimarySource(); + attr_.sourceType = SOURCE_TYPE_VOICE_TRANSCRIPTION; EXPECT_TRUE(primarySource_ && primarySource_->IsInited()); - primarySource_->UpdateActiveDevice(DEVICE_TYPE_MIC); - primarySource_->SetDmDeviceType(DM_DEVICE_TYPE_DEFAULT, DEVICE_TYPE_MIC); - primarySource_->SetDmDeviceType(DM_DEVICE_TYPE_NEARLINK_SCO, DEVICE_TYPE_MIC); + uint32 streamId = AUDIO_HDI_CAPTURE_ID_BASE + HDI_CAPTURE_OFFSET_VOICE_TRANSCRIPTION * UNIQUE_ID_INTERVAL; + EXPECT_EQ(primarySource_->GetUniqueIdBySourceType(), streamId); DeInitPrimarySource(); } @@ -390,5 +391,29 @@ HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_004, TestSize.Level1) DeInitUsbSource(); } +/** + * @tc.name : Test GetChannelCountByChannelLayout API + * @tc.number : GetChannelCountByChannelLayout_001 + * @tc.desc : Test GetChannelCountByChannelLayout API + */ +HWTEST_F(AudioCaptureSourceUnitTest, GetChannelCountByChannelLayout_001, TestSize.Level1) +{ + uint64_t channelCount = 0; + + channelCount = AudioCaptureSource::GetChannelCountByChannelLayout(AudioChannelLayout::CH_LAYOUT_UNKNOWN); + EXPECT_EQ(channelCount, AudioChannel::CHANNEL_UNKNOW); + + channelCount = AudioCaptureSource::GetChannelCountByChannelLayout(AudioChannelLayout::CH_LAYOUT_MONO); + EXPECT_EQ(channelCount, AudioChannel::MONO); + + channelCount = AudioCaptureSource::GetChannelCountByChannelLayout(AudioChannelLayout::CH_LAYOUT_STEREO); + EXPECT_EQ(channelCount, AudioChannel::STEREO); + + channelCount = AudioCaptureSource::GetChannelCountByChannelLayout(AudioChannelLayout::CH_LAYOUT_4POINT0); + EXPECT_EQ(channelCount, AudioChannel::CHANNEL_4); + channelCount = AudioCaptureSource::GetChannelCountByChannelLayout(AudioChannelLayout::CH_LAYOUT_QUAD); + EXPECT_EQ(channelCount, AudioChannel::CHANNEL_4); +} + } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp b/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp index ac887d175037ad754cc8d5a700006b76c20197fd..bfc4a521ca0337c9a7295939021de8c816775e0e 100644 --- a/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp +++ b/frameworks/native/hdiadapter_new/test/unittest/util_unit_test.cpp @@ -30,6 +30,9 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { +constexpr uint64_t TEST_MAX_FRAME_NUM = 5; +constexpr uint64_t TEST_READ_START_POSITION = 10; +constexpr uint64_t TEST_MAX_ARRAY_LEN = 100; class UtilUnitTest : public testing::Test { public: static void SetUpTestCase() {} @@ -176,6 +179,37 @@ HWTEST_F(UtilUnitTest, RingBufferHandlerUnitTest_001, TestSize.Level1) handler->AddWriteIndex(); handler->AddReadIndex(); } +/** + * @tc.name : Test RingBufferHandler API + * @tc.number : RingBufferHandlerUnitTest_002 + * @tc.desc : Test RingBufferHandler action + */ +HWTEST_F(UtilUnitTest, RingBufferHandlerUnitTest_002, TestSize.Level1) +{ + auto ringBuffer = std::make_shared(); + EXPECT_NE(ringBuffer, nullptr); + + const uint32_t dataLen = static_cast(sizeof(uint32_t)); + const uint32_t maxFrameNum = TEST_MAX_FRAME_NUM; + const uint32_t arrayLen = TEST_MAX_ARRAY_LEN; + ringBuffer->Init(arrayLen, 1, dataLen, 1, maxFrameNum); + std::vector testNums; + for (uint32_t i = 0; i < arrayLen; ++i) { + testNums.emplace_back(i); + } + + const uint32_t readStart = TEST_READ_START_POSITION; + for (uint32_t i = 0; i < readStart; ++i) { + EXPECT_EQ(ringBuffer->WriteDataToRingBuffer(reinterpret_cast(&testNums[i]), dataLen), SUCCESS); + } + + for (uint32_t i = readStart; i < arrayLen; ++i) { + EXPECT_EQ(ringBuffer->WriteDataToRingBuffer(reinterpret_cast(&testNums[i]), dataLen), SUCCESS); + uint32_t val = 0; + EXPECT_EQ(ringBuffer->ReadDataFromRingBuffer(reinterpret_cast(&val), dataLen), SUCCESS); + EXPECT_EQ(val, testNums[i - maxFrameNum + 1]); + } +} /** * @tc.name : Test CallbackWrapper API diff --git a/frameworks/native/hdiadapter_new/util/id_handler.cpp b/frameworks/native/hdiadapter_new/util/id_handler.cpp index 6f9f7a6848c60eb71f14c0680ea107ef3e5be049..cf9ab8bc6c86d401f54e3b9107a9533b9c923276 100644 --- a/frameworks/native/hdiadapter_new/util/id_handler.cpp +++ b/frameworks/native/hdiadapter_new/util/id_handler.cpp @@ -104,6 +104,9 @@ uint32_t IdHandler::GetCaptureIdByDeviceClass(const std::string &deviceClass, co if (info == HDI_ID_INFO_EC || info == HDI_ID_INFO_MIC_REF) { return GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_PRIMARY, info); } + if (sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION) { + return GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_AI, HDI_ID_INFO_DEFAULT); + } return GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_DEFAULT); } else if (deviceClass == "usb") { return GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_USB); diff --git a/frameworks/native/hdiadapter_new/util/ring_buffer_handler.cpp b/frameworks/native/hdiadapter_new/util/ring_buffer_handler.cpp index 97c5583b5c1a2587616ebfce3ebae17b858b40c5..7bcdc6eb360eea1ece4984c1cb4aba084454ceda 100644 --- a/frameworks/native/hdiadapter_new/util/ring_buffer_handler.cpp +++ b/frameworks/native/hdiadapter_new/util/ring_buffer_handler.cpp @@ -84,25 +84,20 @@ int32_t RingBufferHandler::ReadDataFromRingBuffer(uint8_t *data, uint32_t dataLe void RingBufferHandler::AddWriteIndex(void) { - if (writeIdx_ < UINT64_MAX) { - ++writeIdx_; - return; + if (writeIdx_ >= UINT64_MAX) { + uint64_t diff = (writeIdx_ - readIdx_) % maxFrameNum_; + readIdx_ = readIdx_ % maxFrameNum_; + writeIdx_ = readIdx_ + diff; } - - uint64_t diff = (writeIdx_ - readIdx_) % maxFrameNum_; - writeIdx_ = writeIdx_ % maxFrameNum_; - readIdx_ = writeIdx_ - diff; ++writeIdx_; + if (writeIdx_ - readIdx_ >= maxFrameNum_) { + ++readIdx_; + } } void RingBufferHandler::AddReadIndex(void) { - if (readIdx_ < UINT64_MAX) { - ++readIdx_; - return; - } - - readIdx_ = 0; + ++readIdx_; } } // namespace AudioStandard diff --git a/frameworks/native/ohaudio/OHAudioRenderer.cpp b/frameworks/native/ohaudio/OHAudioRenderer.cpp index fbbd47bcbd7fbcd9b654fa79ba4e2984fa90d424..b87aa740c747000c290d811005460885a7f01173 100644 --- a/frameworks/native/ohaudio/OHAudioRenderer.cpp +++ b/frameworks/native/ohaudio/OHAudioRenderer.cpp @@ -874,7 +874,7 @@ void OHAudioRendererModeCallback::OnWriteData(size_t length) } bufDesc.dataLength = static_cast(writeFrameInByte); - bufDesc.bufLength = static_cast(writeFrameInByte); + bufDesc.bufLength = (writeFrameInByte == 0) ? bufDesc.bufLength : static_cast(writeFrameInByte); } } audioRenderer->Enqueue(bufDesc); diff --git a/frameworks/native/pulseaudio/modules/hdi/hdi_sink.c b/frameworks/native/pulseaudio/modules/hdi/hdi_sink.c index 4c3814f484dde61d172ad884b53637617fe7f138..9116652dd5bcea66a109953d29ae206da8345a0e 100644 --- a/frameworks/native/pulseaudio/modules/hdi/hdi_sink.c +++ b/frameworks/native/pulseaudio/modules/hdi/hdi_sink.c @@ -2512,11 +2512,7 @@ static bool InputIsOffload(pa_sink_input *i) if (!u->offload_enable || !u->offload.inited) { return false; } - const char *offloadEnableStr = pa_proplist_gets(i->proplist, "stream.offload.enable"); - if (offloadEnableStr == NULL) { - return false; - } - const bool offloadEnable = !strcmp(offloadEnableStr, "1"); + const bool offloadEnable = (GetOffloadEnable(i->index) == 1); return offloadEnable; } diff --git a/frameworks/native/toneplayer/test/unittest/audio_toneplayer_unit_test.cpp b/frameworks/native/toneplayer/test/unittest/audio_toneplayer_unit_test.cpp index 42219ef04fb4b1997de7b7dfad8952212d5d772d..9b386b3aafa732812c8a0d3bcf2c50a6cd5cb6dc 100644 --- a/frameworks/native/toneplayer/test/unittest/audio_toneplayer_unit_test.cpp +++ b/frameworks/native/toneplayer/test/unittest/audio_toneplayer_unit_test.cpp @@ -1355,5 +1355,62 @@ HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_024, TestSize.Level4) EXPECT_EQ(ret, true); } +/** + * @tc.name : Test TonePlayerImpl API + * @tc.type : FUNC + * @tc.number: TonePlayerImpl_025 + * @tc.desc : Test CheckToneStopped interface. + */ +HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_025, TestSize.Level4) +{ + AudioRendererInfo rendererInfo = {}; + rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; + rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF; + rendererInfo.rendererFlags = 0; + + std::shared_ptr toneplayer = std::make_shared("", rendererInfo); + EXPECT_NE(toneplayer, nullptr); + + toneplayer->toneInfo_ = std::make_shared(); + EXPECT_NE(toneplayer->toneInfo_, nullptr); + + toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING; + toneplayer->currSegment_ = 0; + toneplayer->totalSample_ = 9000; + toneplayer->maxSample_ = 8000; + toneplayer->toneInfo_->segments[1].duration = 1; + + bool ret = toneplayer->CheckToneStopped(); + EXPECT_EQ(ret, true); +} + +/** + * @tc.name : Test TonePlayerImpl API + * @tc.type : FUNC + * @tc.number: TonePlayerImpl_026 + * @tc.desc : Test CheckToneStopped interface. + */ +HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_026, TestSize.Level4) +{ + AudioRendererInfo rendererInfo = {}; + rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; + rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF; + rendererInfo.rendererFlags = 0; + + std::shared_ptr toneplayer = std::make_shared("", rendererInfo); + EXPECT_NE(toneplayer, nullptr); + + toneplayer->toneInfo_ = std::make_shared(); + EXPECT_NE(toneplayer->toneInfo_, nullptr); + + toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING; + toneplayer->currSegment_ = 0; + toneplayer->totalSample_ = 8000; + toneplayer->maxSample_ = 8000; + toneplayer->toneInfo_->segments[1].duration = 0; + + bool ret = toneplayer->CheckToneStopped(); + EXPECT_EQ(ret, true); +} } // namespace AudioStandard } // namespace OHOS diff --git a/interfaces/inner_api/native/audiocommon/include/audio_device_descriptor.h b/interfaces/inner_api/native/audiocommon/include/audio_device_descriptor.h index ea99a3957125531cbd8f64623e475dbecf22cd8a..ec8bee75883d64f77cba65a9e3519380beddc35f 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_device_descriptor.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_device_descriptor.h @@ -21,6 +21,7 @@ #include "parcel.h" #include "audio_device_info.h" #include "audio_info.h" +#include namespace OHOS { namespace AudioStandard { @@ -97,6 +98,8 @@ public: bool IsDistributedSpeaker() const; + bool IsRemote() const; + DeviceType MapInternalToExternalDeviceType(int32_t apiVersion) const; DeviceStreamInfo GetDeviceStreamInfo(void) const; @@ -136,7 +139,7 @@ public: } }; - void SetClientInfo(std::shared_ptr clientInfo) const; + void SetClientInfo(const ClientInfo &clientInfo) const; private: static void FixApiCompatibility(int apiVersion, DeviceRole deviceRole, DeviceType &deviceType, int32_t &deviceId, std::list &streamInfo); @@ -179,7 +182,7 @@ public: bool hasPair_{false}; RouterType routerType_ = ROUTER_TYPE_NONE; bool isVrSupported_ = true; - mutable std::shared_ptr clientInfo_ = nullptr; + mutable std::optional clientInfo_ = std::nullopt; VolumeBehavior volumeBehavior_; private: diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h index d984c5f3857342036547b4b8b5e10a04efe41fef..2c918e8188d9b69ce88bc45e2e530bcacff1edac 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h @@ -59,6 +59,7 @@ constexpr int32_t AUDIO_FLAG_VKB_FAST = 1025; constexpr int32_t AUDIO_USAGE_NORMAL = 0; constexpr int32_t AUDIO_USAGE_VOIP = 1; constexpr uint32_t STREAM_FLAG_FAST = 1; +constexpr uint32_t DEFAULT_SUSPEND_TIME_IN_MS = 3000; constexpr float MAX_STREAM_SPEED_LEVEL = 4.0f; constexpr float MIN_STREAM_SPEED_LEVEL = 0.125f; constexpr float NORMAL_STREAM_SPEED_LEVEL = 1.0f; @@ -598,6 +599,7 @@ enum AudioLoopbackEqualizerPreset { struct AudioRendererInfo : public Parcelable { ContentType contentType = CONTENT_TYPE_UNKNOWN; StreamUsage streamUsage = STREAM_USAGE_UNKNOWN; + bool forceToNormal = false; int32_t rendererFlags = AUDIO_FLAG_NORMAL; AudioVolumeMode volumeMode = AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL; std::string sceneType = ""; @@ -630,11 +632,14 @@ struct AudioRendererInfo : public Parcelable { int32_t rendererFlagsIn, AudioVolumeMode volumeModeIn) : contentType(contentTypeIn), streamUsage(streamUsageIn), rendererFlags(rendererFlagsIn), volumeMode(volumeModeIn) {} + AudioRendererInfo(ContentType contentTypeIn, StreamUsage streamUsageIn) + : contentType(contentTypeIn), streamUsage(streamUsageIn) {} bool Marshalling(Parcel &parcel) const override { return parcel.WriteInt32(static_cast(contentType)) && parcel.WriteInt32(static_cast(streamUsage)) + && parcel.WriteBool(forceToNormal) && parcel.WriteInt32(rendererFlags) && parcel.WriteInt32(originalFlag) && parcel.WriteString(sceneType) @@ -659,6 +664,7 @@ struct AudioRendererInfo : public Parcelable { { contentType = static_cast(parcel.ReadInt32()); streamUsage = static_cast(parcel.ReadInt32()); + forceToNormal = parcel.ReadBool(); rendererFlags = parcel.ReadInt32(); originalFlag = parcel.ReadInt32(); sceneType = parcel.ReadString(); diff --git a/interfaces/inner_api/native/audiocommon/include/audio_interrupt_info.h b/interfaces/inner_api/native/audiocommon/include/audio_interrupt_info.h index a303b6f778d6915c63d01ce37d8767944f512bd9..62a75dc9e7a9ec77a8ae61032c18bad44d632c46 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_interrupt_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_interrupt_info.h @@ -154,6 +154,7 @@ struct InterruptEventInternal : public Parcelable { InterruptHint hintType = INTERRUPT_HINT_NONE; float duckVolume = 1.0f; bool callbackToApp = true; + int64_t eventTimestamp = 0; InterruptEventInternal() = default; @@ -164,6 +165,7 @@ struct InterruptEventInternal : public Parcelable { forceType = forcetype; hintType = hinttype; duckVolume = duckvolume; + eventTimestamp = 0; } bool Marshalling(Parcel &parcel) const override @@ -172,21 +174,23 @@ struct InterruptEventInternal : public Parcelable { && parcel.WriteInt32(static_cast(forceType)) && parcel.WriteInt32(static_cast(hintType)) && parcel.WriteFloat(duckVolume) - && parcel.WriteBool(callbackToApp); + && parcel.WriteBool(callbackToApp) + && parcel.WriteInt64(eventTimestamp); } static InterruptEventInternal *Unmarshalling(Parcel &parcel) { - auto interupt = new(std::nothrow) InterruptEventInternal(); - if (interupt == nullptr) { + auto interrupt = new(std::nothrow) InterruptEventInternal(); + if (interrupt == nullptr) { return nullptr; } - interupt->eventType = static_cast(parcel.ReadInt32()); - interupt->forceType = static_cast(parcel.ReadInt32()); - interupt->hintType = static_cast(parcel.ReadInt32()); - interupt->duckVolume = parcel.ReadFloat(); - interupt->callbackToApp = parcel.ReadBool(); - return interupt; + interrupt->eventType = static_cast(parcel.ReadInt32()); + interrupt->forceType = static_cast(parcel.ReadInt32()); + interrupt->hintType = static_cast(parcel.ReadInt32()); + interrupt->duckVolume = parcel.ReadFloat(); + interrupt->callbackToApp = parcel.ReadBool(); + interrupt->eventTimestamp = parcel.ReadInt64(); + return interrupt; } }; diff --git a/interfaces/inner_api/native/audiocommon/include/audio_stream_change_info.h b/interfaces/inner_api/native/audiocommon/include/audio_stream_change_info.h index 4bccbe3c4af259772250c80e3fa2839043a4dbb0..5970d142d08799b979040c459d23ea0df0d7c904 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_stream_change_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_stream_change_info.h @@ -36,7 +36,7 @@ public: bool prerunningState = false; bool backMute = false; int32_t appVolume; - mutable std::shared_ptr clientInfo_ = nullptr; + mutable std::optional clientInfo_ = std::nullopt; AudioRendererChangeInfo(const AudioRendererChangeInfo &audioRendererChangeInfo) { @@ -45,7 +45,7 @@ public: AudioRendererChangeInfo() = default; ~AudioRendererChangeInfo() = default; - void SetClientInfo(std::shared_ptr clientInfo) const + void SetClientInfo(const AudioDeviceDescriptor::ClientInfo &clientInfo) const { clientInfo_ = clientInfo; outputDeviceInfo.SetClientInfo(clientInfo); @@ -55,10 +55,10 @@ public: { int32_t clientUIDTemp = clientUID; RendererState rendererStateTemp = rendererState; - if (clientInfo_ != nullptr) { - clientUIDTemp = clientInfo_->hasSystemPermission_ ? clientUID : EMPTY_UID; - rendererStateTemp = clientInfo_->hasSystemPermission_ ? rendererState : RENDERER_INVALID; - clientInfo_ = nullptr; + if (clientInfo_) { + clientUIDTemp = clientInfo_.value().hasSystemPermission_ ? clientUID : EMPTY_UID; + rendererStateTemp = clientInfo_.value().hasSystemPermission_ ? rendererState : RENDERER_INVALID; + clientInfo_ = std::nullopt; } return parcel.WriteInt32(createrUID) && parcel.WriteInt32(clientUIDTemp) @@ -127,7 +127,7 @@ public: bool prerunningState = false; bool muted; uint32_t appTokenId; - mutable std::shared_ptr clientInfo_ = nullptr; + mutable std::optional clientInfo_ = std::nullopt; AudioCapturerChangeInfo(const AudioCapturerChangeInfo &audioCapturerChangeInfo) { @@ -136,7 +136,7 @@ public: AudioCapturerChangeInfo() = default; ~AudioCapturerChangeInfo() = default; - void SetClientInfo(std::shared_ptr clientInfo) const + void SetClientInfo(const AudioDeviceDescriptor::ClientInfo &clientInfo) const { clientInfo_ = clientInfo; inputDeviceInfo.SetClientInfo(clientInfo); @@ -146,10 +146,10 @@ public: { int32_t clientUIDTemp = clientUID; CapturerState capturerStateTemp = capturerState; - if (clientInfo_ != nullptr) { - clientUIDTemp = clientInfo_->hasSystemPermission_ ? clientUID : EMPTY_UID; - capturerStateTemp = clientInfo_->hasSystemPermission_ ? capturerState : CAPTURER_INVALID; - clientInfo_ = nullptr; + if (clientInfo_) { + clientUIDTemp = clientInfo_.value().hasSystemPermission_ ? clientUID : EMPTY_UID; + capturerStateTemp = clientInfo_.value().hasSystemPermission_ ? capturerState : CAPTURER_INVALID; + clientInfo_ = std::nullopt; } return parcel.WriteInt32(createrUID) && parcel.WriteInt32(clientUIDTemp) diff --git a/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h b/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h index 10e67b96d5e939c3e9c04efedc13fa2d3a8dc684..6eff6c7000f50ac31f96afb0e4b31f8aca10f80a 100644 --- a/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h +++ b/interfaces/inner_api/native/audiocommon/include/audio_stream_info.h @@ -253,6 +253,7 @@ enum AudioPipeType { PIPE_TYPE_SPATIALIZATION = 12, PIPE_TYPE_DIRECT_MUSIC = 13, PIPE_TYPE_DIRECT_VOIP = 14, + PIPE_TYPE_NORMAL_IN_AI = 15, }; enum AudioPreloadType { @@ -553,6 +554,19 @@ const std::vector AUDIO_SUPPORTED_STREAM_USAGES { STREAM_USAGE_VOICE_CALL_ASSISTANT, }; +enum FunctionHoldType { + FUNCTION_HOLD_INVALID = -1, + FUNCTION_HOLD_MUSIC, + FUNCTION_HOLD_SYSTEM, +}; + +enum SetLoudVolMode { + LOUD_VOLUME_SWITCH_INVALID = -1, + LOUD_VOLUME_SWITCH_UNSET, + LOUD_VOLUME_SWITCH_OFF, + LOUD_VOLUME_SWITCH_ON, +}; + class AudioStreamInfo : public Parcelable { public: AudioSamplingRate samplingRate; 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 d3e9eb74fbc06b8574d779a7609f0492de8eb50d..9e11ae84fcbc89de3fd5fd46f60a108677652fa4 100644 --- a/interfaces/inner_api/native/audiomanager/include/audio_policy_interface.h +++ b/interfaces/inner_api/native/audiomanager/include/audio_policy_interface.h @@ -38,7 +38,7 @@ struct DeviceChangeAction : public Parcelable { std::vector> deviceDescriptors; static constexpr int32_t DEVICE_CHANGE_VALID_SIZE = 128; - void SetClientInfo(std::shared_ptr clientInfo) const + void SetClientInfo(const AudioDeviceDescriptor::ClientInfo &clientInfo) const { for (auto &des : deviceDescriptors) { if (des != nullptr) { diff --git a/interfaces/inner_api/native/audiomanager/include/audio_system_manager.h b/interfaces/inner_api/native/audiomanager/include/audio_system_manager.h index 024967737609bd4ee72bc167e15ad4b24bf8baf7..344265be60d6a60e219a69a6bd33e19cf65c8f2e 100644 --- a/interfaces/inner_api/native/audiomanager/include/audio_system_manager.h +++ b/interfaces/inner_api/native/audiomanager/include/audio_system_manager.h @@ -1497,6 +1497,16 @@ public: */ int32_t ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration); + /** + * @brief set stream volume by sessionId. + * + * @param sessionId stream sessionId. + * @param volume return stream volume. + * @return Returns {@link SUCCESS} if the operation is successfully. + * @test + */ + int32_t GetVolumeBySessionId(const uint32_t &sessionId, float &volume); + class WorkgroupPrioRecorder { public: WorkgroupPrioRecorder(int32_t grpId); diff --git a/interfaces/inner_api/native/audiomanager/include/audio_system_manager_ext.h b/interfaces/inner_api/native/audiomanager/include/audio_system_manager_ext.h index 6631180e653d9da02f37ab53858b180d354d5fde..b0dcf11fb6d67f2b99a3554db16a1588072b17d7 100644 --- a/interfaces/inner_api/native/audiomanager/include/audio_system_manager_ext.h +++ b/interfaces/inner_api/native/audiomanager/include/audio_system_manager_ext.h @@ -121,7 +121,7 @@ struct MicrophoneBlockedInfo : public Parcelable { std::vector> devices; static constexpr int32_t DEVICE_CHANGE_VALID_SIZE = 128; - void SetClientInfo(std::shared_ptr clientInfo) const + void SetClientInfo(const AudioDeviceDescriptor::ClientInfo &clientInfo) const { for (auto &dev : devices) { if (dev != nullptr) { diff --git a/services/audio_engine/buffer/hpae_pcm_buffer.h b/services/audio_engine/buffer/hpae_pcm_buffer.h index ba8cbb8a5cf0137091a47e495da0aa68ed3dfbe9..644e5b59feee67b833c6a54b499fee4ca7524bcc 100644 --- a/services/audio_engine/buffer/hpae_pcm_buffer.h +++ b/services/audio_engine/buffer/hpae_pcm_buffer.h @@ -19,6 +19,7 @@ #include #include #include +#include "audio_stream_info.h" #include "hpae_pcm_process.h" namespace OHOS { namespace AudioStandard { @@ -257,6 +258,16 @@ public: splitStreamType_ = type; } + void SetAudioStreamType(AudioStreamType type) + { + streamType_ = type; + } + + AudioStreamType GetAudioStreamType() + { + return streamType_; + } + private: void InitPcmProcess(); @@ -275,6 +286,7 @@ private: PcmBufferInfo pcmBufferInfo_; HpaeSourceBufferType sourceBufferType_ = HPAE_SOURCE_BUFFER_TYPE_DEFAULT; HpaeSplitStreamType splitStreamType_ = STREAM_TYPE_DEFAULT; + AudioStreamType streamType_ = STREAM_DEFAULT; }; } // namespace HPAE } // namespace AudioStandard diff --git a/services/audio_engine/dfx/hpae_dfx_tree.cpp b/services/audio_engine/dfx/hpae_dfx_tree.cpp index 46d748eeedae88d04af2c6ca26a2da1e9c0799eb..d80ad8e475284908aca5b6672db2f29c1baf6bc8 100644 --- a/services/audio_engine/dfx/hpae_dfx_tree.cpp +++ b/services/audio_engine/dfx/hpae_dfx_tree.cpp @@ -146,7 +146,8 @@ void HpaeDfxTree::PrintNodeInfo(std::string &outStr, HpaeDfxNodeInfo &nodeInfo) outStr = outStr + "ch[" + std::to_string(nodeInfo.channels) + "],"; outStr = outStr + "bw[" + std::to_string(nodeInfo.format) + "],"; outStr = outStr + "len[" + std::to_string(nodeInfo.frameLen) + "],"; - outStr = outStr + "scene[" + std::to_string(nodeInfo.sceneType) + "] \n"; + outStr = outStr + "scene[" + std::to_string(nodeInfo.sceneType) + "],"; + outStr = outStr + "streamType[" + std::to_string(nodeInfo.streamType) + "] \n"; } void HpaeDfxTree::PrintSubTree(DfxTreeNode *node, const std::string &prefix, bool isLastChild, std::string &outStr) diff --git a/services/audio_engine/manager/include/hpae_manager.h b/services/audio_engine/manager/include/hpae_manager.h index 87e4bb001480e01d18baaaed5dd43e4b60a1965c..8bf4e11c60c7690cf076d084ea05556dfbad3dc8 100644 --- a/services/audio_engine/manager/include/hpae_manager.h +++ b/services/audio_engine/manager/include/hpae_manager.h @@ -104,6 +104,7 @@ public: int32_t GetMsgCount(); void Invoke(HpaeMsgCode cmdID, const std::any &args) override; + void InvokeSync(HpaeMsgCode cmdID, const std::any &args) override; // play and record stream interface int32_t CreateStream(const HpaeStreamInfo &streamInfo) override; int32_t DestroyStream(HpaeStreamClassType streamClassType, uint32_t sessionId) override; diff --git a/services/audio_engine/manager/include/hpae_msg_channel.h b/services/audio_engine/manager/include/hpae_msg_channel.h index 0887ec6f64c9f8f9de7491b4bb81395292bb8ef9..6410a2a8ce76dd33c2b464d62a5e383cfbf0ab7a 100644 --- a/services/audio_engine/manager/include/hpae_msg_channel.h +++ b/services/audio_engine/manager/include/hpae_msg_channel.h @@ -44,6 +44,7 @@ enum NodeOperation { UNDERFLOW, FADED, DRAINED }; class ISendMsgCallback { public: virtual void Invoke(HpaeMsgCode cmdID, const std::any &args) = 0; + virtual void InvokeSync(HpaeMsgCode cmdID, const std::any &args) = 0; }; class CallbackSender { @@ -65,6 +66,16 @@ public: callback->Invoke(cmdID, packed); } } + + template + void TriggerSyncCallback(HpaeMsgCode cmdID, Args &&...args) + { + if (auto callback = weakCallback_.lock()) { + // pack the arguments into a tuple + auto packed = std::make_tuple(std::forward(args)...); + callback->InvokeSync(cmdID, packed); + } + } }; enum HpaeProcessorType { diff --git a/services/audio_engine/manager/include/hpae_renderer_manager.h b/services/audio_engine/manager/include/hpae_renderer_manager.h index b0733358775db6e3eca923cd05f553d7351b5c25..241739271724d5950b9edce91a637598fda83a64 100644 --- a/services/audio_engine/manager/include/hpae_renderer_manager.h +++ b/services/audio_engine/manager/include/hpae_renderer_manager.h @@ -135,8 +135,11 @@ private: void EnableCollaboration(); void DisableCollaboration(); int32_t HandleSyncId(uint32_t sessionId, int32_t syncId); - int32_t DeleteProcessCluster(HpaeProcessorType sceneType); + int32_t DeleteProcessCluster(uint32_t sessionId); + int32_t DeleteProcessClusterInner(HpaeProcessorType sceneType); void RefreshProcessClusterByDeviceInner(const std::shared_ptr &node); + void TriggerStreamState(uint32_t sessionId, const std::shared_ptr &node); + void UpdateStreamType(const std::shared_ptr sourceNode, std::shared_ptr dstNode); private: std::unordered_map sessionNodeMap_; diff --git a/services/audio_engine/manager/src/hpae_capturer_manager.cpp b/services/audio_engine/manager/src/hpae_capturer_manager.cpp index b2b0a8ff6257d458526dce1683840f9bc5202c89..03fd27124ba935e0f3eaebc1e4b54f34340e81b6 100644 --- a/services/audio_engine/manager/src/hpae_capturer_manager.cpp +++ b/services/audio_engine/manager/src/hpae_capturer_manager.cpp @@ -909,7 +909,11 @@ void HpaeCapturerManager::MoveAllStreamToNewSource(const std::string &sourceName } AUDIO_INFO_LOG("[StartMove] session:%{public}s to source name:%{public}s, move type:%{public}d", idStr.c_str(), name.c_str(), moveType); - TriggerCallback(MOVE_ALL_SOURCE_OUTPUT, moveInfos, name); + if (moveType == MOVE_ALL) { + TriggerSyncCallback(MOVE_ALL_SOURCE_OUTPUT, moveInfos, name); + } else { + TriggerCallback(MOVE_ALL_SOURCE_OUTPUT, moveInfos, name); + } } int32_t HpaeCapturerManager::MoveStream(uint32_t sessionId, const std::string& sourceName) diff --git a/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp b/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp index dcacd417638a96f5164c681f7f2c9941bd54b738..84eef165c892c804cf63078c20dce9a127b7460f 100644 --- a/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp +++ b/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp @@ -118,7 +118,11 @@ void HpaeInnerCapturerManager::MoveAllStreamToNewSinkInner(const std::string &si } AUDIO_INFO_LOG("[StartMove] session:%{public}s to sink name:%{public}s, move type:%{public}d", idStr.c_str(), name.c_str(), moveType); - TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + if (moveType == MOVE_ALL) { + TriggerSyncCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + } else { + TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + } } int32_t HpaeInnerCapturerManager::MoveAllStream(const std::string &sinkName, const std::vector& sessionIds, diff --git a/services/audio_engine/manager/src/hpae_manager.cpp b/services/audio_engine/manager/src/hpae_manager.cpp index 3152ebd13771fc55a057d5f52d1fa46dba9fc742..1978095e38da77f8cbacc69a61aecc244d759a39 100644 --- a/services/audio_engine/manager/src/hpae_manager.cpp +++ b/services/audio_engine/manager/src/hpae_manager.cpp @@ -33,7 +33,6 @@ namespace OHOS { namespace AudioStandard { namespace HPAE { namespace { -constexpr uint32_t DEFAULT_SUSPEND_TIME_IN_MS = 3000; // 3s to stop hdi static inline const std::unordered_set INNER_SOURCE_TYPE_SET = { SOURCE_TYPE_PLAYBACK_CAPTURE, SOURCE_TYPE_REMOTE_CAST}; } // namespace @@ -238,7 +237,6 @@ int32_t HpaeManager::ReloadRenderManager(const AudioModuleInfo &audioModuleInfo, { HpaeSinkInfo sinkInfo; sinkInfo.sinkId = sinkNameSinkIdMap_[audioModuleInfo.name]; - sinkInfo.suspendTime = DEFAULT_SUSPEND_TIME_IN_MS; int32_t ret = TransModuleInfoToHpaeSinkInfo(audioModuleInfo, sinkInfo); if (ret != SUCCESS) { OnCallbackOpenOrReloadFailed(isReload); @@ -262,7 +260,6 @@ int32_t HpaeManager::CreateRendererManager(const AudioModuleInfo &audioModuleInf sinkSourceIndex_.fetch_add(1); HpaeSinkInfo sinkInfo; sinkInfo.sinkId = sinkSourceIndex; - sinkInfo.suspendTime = DEFAULT_SUSPEND_TIME_IN_MS; int32_t ret = TransModuleInfoToHpaeSinkInfo(audioModuleInfo, sinkInfo); if (ret != SUCCESS) { OnCallbackOpenOrReloadFailed(isReload); @@ -888,6 +885,16 @@ void HpaeManager::Invoke(HpaeMsgCode cmdID, const std::any &args) AUDIO_ERR_LOG("HpaeManager::Invoke cmdID %{public}d not found", (int32_t)cmdID); } +void HpaeManager::InvokeSync(HpaeMsgCode cmdID, const std::any &args) +{ + auto it = handlers_.find(cmdID); + if (it != handlers_.end()) { + it->second(args); + return; + }; + AUDIO_ERR_LOG("HpaeManager::InvokeSync cmdID %{public}d not found", (int32_t)cmdID); +} + template void HpaeManager::RegisterHandler(HpaeMsgCode cmdID, void (HpaeManager::*func)(Args...)) { diff --git a/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp b/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp index 92c7470cd0dcbcf3e7e24f5493346189549a753d..3384ae45c93ddba25637ec5ae59dfaf165c67ce8 100644 --- a/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp +++ b/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp @@ -298,7 +298,11 @@ void HpaeOffloadRendererManager::MoveAllStreamToNewSink(const std::string &sinkN if (sinkInputs.size() == 0) { AUDIO_WARNING_LOG("sink count is 0,no need move session"); } - TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + if (moveType == MOVE_ALL) { + TriggerSyncCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + } else { + TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + } } int32_t HpaeOffloadRendererManager::MoveAllStream(const std::string &sinkName, const std::vector& sessionIds, diff --git a/services/audio_engine/manager/src/hpae_renderer_manager.cpp b/services/audio_engine/manager/src/hpae_renderer_manager.cpp index 2d4654571654459186b44db80746618ac852b3fc..daac83d5bb93fb430beb3d40a138f74efcd39305 100644 --- a/services/audio_engine/manager/src/hpae_renderer_manager.cpp +++ b/services/audio_engine/manager/src/hpae_renderer_manager.cpp @@ -262,8 +262,8 @@ void HpaeRendererManager::RefreshProcessClusterByDeviceInner(const std::shared_p int32_t processClusterDecision = AudioEffectChainManager::GetInstance()->CheckProcessClusterInstances(sceneType); bool isConnected = (node->isConnected_) ? true : false; if (processClusterDecision != USE_NONE_PROCESSCLUSTER && sessionNodeMap_[nodeInfo.sessionId].bypass) { - DeleteConnectInputProcessor(sinkInputNodeMap_[nodeInfo.sessionId]); - DeleteProcessCluster(GetProcessorType(nodeInfo.sessionId)); + AUDIO_INFO_LOG("current processCluster is incorrect, refresh to %{public}d", processClusterDecision); + DeleteProcessCluster(nodeInfo.sessionId); CreateProcessClusterInner(nodeInfo, processClusterDecision); CHECK_AND_RETURN_LOG(SafeGetMap(sceneClusterMap_, nodeInfo.sceneType), "could not find processorType %{public}d", nodeInfo.sceneType); @@ -273,8 +273,8 @@ void HpaeRendererManager::RefreshProcessClusterByDeviceInner(const std::shared_p ConnectInputSession(nodeInfo.sessionId); } } else if (processClusterDecision == USE_NONE_PROCESSCLUSTER && !sessionNodeMap_[nodeInfo.sessionId].bypass) { - DeleteConnectInputProcessor(sinkInputNodeMap_[nodeInfo.sessionId]); - DeleteProcessCluster(GetProcessorType(nodeInfo.sessionId)); + AUDIO_INFO_LOG("current processCluster is incorrect, refresh to %{public}d", processClusterDecision); + DeleteProcessCluster(nodeInfo.sessionId); sessionNodeMap_[nodeInfo.sessionId].bypass = true; if (isConnected) { ConnectInputSession(nodeInfo.sessionId); @@ -361,26 +361,7 @@ int32_t HpaeRendererManager::DeleteInputSession(uint32_t sessionId) int32_t HpaeRendererManager::DeleteInputSessionForMove(uint32_t sessionId) { Trace trace("[" + std::to_string(sessionId) + "]HpaeRendererManager::DeleteInputSessionForMove"); - if (!SafeGetMap(sinkInputNodeMap_, sessionId)) { - AUDIO_INFO_LOG("could not find session:%{public}d", sessionId); - return SUCCESS; - } - HpaeNodeInfo nodeInfo = sinkInputNodeMap_[sessionId]->GetNodeInfo(); - HpaeProcessorType sceneType = GetProcessorType(sessionId); - if (SafeGetMap(sceneClusterMap_, sceneType)) { - DisConnectProcessCluster(nodeInfo, sceneType, sessionId); - if (sceneClusterMap_[sceneType]->GetPreOutNum() == 0) { - sceneClusterMap_[sceneType]->DisConnectMixerNode(); - outputCluster_->DisConnect(sceneClusterMap_[sceneType]); - // for collaboration - if (sceneType == HPAE_SCENE_COLLABORATIVE && hpaeCoBufferNode_ != nullptr) { - hpaeCoBufferNode_->DisConnect(sceneClusterMap_[sceneType]); - TriggerCallback(DISCONNECT_CO_BUFFER_NODE, hpaeCoBufferNode_); - } - sceneClusterMap_[sceneType]->SetConnectedFlag(false); - } - } - DeleteProcessCluster(sceneType); + DeleteProcessCluster(sessionId); sinkInputNodeMap_.erase(sessionId); sessionNodeMap_.erase(sessionId); return SUCCESS; @@ -409,7 +390,7 @@ void HpaeRendererManager::DisConnectProcessCluster( } } -int32_t HpaeRendererManager::DeleteProcessCluster(HpaeProcessorType sceneType) +int32_t HpaeRendererManager::DeleteProcessClusterInner(HpaeProcessorType sceneType) { if (sceneTypeToProcessClusterCountMap_[sceneType] == 0) { sceneClusterMap_.erase(sceneType); @@ -422,6 +403,31 @@ int32_t HpaeRendererManager::DeleteProcessCluster(HpaeProcessorType sceneType) return SUCCESS; } +int32_t HpaeRendererManager::DeleteProcessCluster(uint32_t sessionId) +{ + if (!SafeGetMap(sinkInputNodeMap_, sessionId)) { + AUDIO_INFO_LOG("could not find session:%{public}d", sessionId); + return SUCCESS; + } + HpaeNodeInfo nodeInfo = sinkInputNodeMap_[sessionId]->GetNodeInfo(); + HpaeProcessorType sceneType = GetProcessorType(sessionId); + if (SafeGetMap(sceneClusterMap_, sceneType)) { + DisConnectProcessCluster(nodeInfo, sceneType, sessionId); + if (sceneClusterMap_[sceneType]->GetPreOutNum() == 0) { + sceneClusterMap_[sceneType]->DisConnectMixerNode(); + outputCluster_->DisConnect(sceneClusterMap_[sceneType]); + // for collaboration + if (sceneType == HPAE_SCENE_COLLABORATIVE && hpaeCoBufferNode_ != nullptr) { + hpaeCoBufferNode_->DisConnect(sceneClusterMap_[sceneType]); + TriggerCallback(DISCONNECT_CO_BUFFER_NODE, hpaeCoBufferNode_); + } + sceneClusterMap_[sceneType]->SetConnectedFlag(false); + } + } + DeleteProcessClusterInner(sceneType); + return SUCCESS; +} + bool HpaeRendererManager::isSplitProcessorType(HpaeProcessorType sceneType) { if (sceneType == HPAE_SCENE_SPLIT_MEDIA || sceneType == HPAE_SCENE_SPLIT_NAVIGATION || @@ -452,6 +458,18 @@ int32_t HpaeRendererManager::ConnectInputSession(uint32_t sessionId) return SUCCESS; } +void HpaeRendererManager::UpdateStreamType(const std::shared_ptr sourceNode, + std::shared_ptr dstNode) +{ + if (sourceNode == nullptr || dstNode == nullptr) { + AUDIO_ERR_LOG("copy node err, node is null"); + return; + } + HpaeNodeInfo tmpNodeInfo = dstNode->GetNodeInfo(); + tmpNodeInfo.streamType = sourceNode->GetNodeInfo().streamType; + dstNode->SetNodeInfo(tmpNodeInfo); +} + void HpaeRendererManager::ConnectProcessCluster(uint32_t sessionId, HpaeProcessorType sceneType) { Trace trace("[" + std::to_string(sessionId) + "]HpaeRendererManager::ConnectProcessCluster sceneType:" @@ -478,9 +496,13 @@ void HpaeRendererManager::ConnectProcessCluster(uint32_t sessionId, HpaeProcesso AUDIO_WARNING_LOG("update audio effect when starting failed, ret = %{public}d", ret); } } + // update node info for processcluster + UpdateStreamType(sinkInputNodeMap_[sessionId], sceneClusterMap_[sceneType]->GetSharedInstance()); if (!outputCluster_->IsProcessClusterConnected(sceneType) && !sceneClusterMap_[sceneType]->GetConnectedFlag()) { outputCluster_->Connect(sceneClusterMap_[sceneType]); sceneClusterMap_[sceneType]->SetConnectedFlag(true); + } else { + outputCluster_->UpdateStreamInfo(sceneClusterMap_[sceneType]); } sceneClusterMap_[sceneType]->Connect(sinkInputNodeMap_[sessionId]); sinkInputNodeMap_[sessionId]->isConnected_ = true; @@ -515,7 +537,11 @@ void HpaeRendererManager::MoveAllStreamToNewSink(const std::string &sinkName, } AUDIO_INFO_LOG("[StartMove] session:%{public}s to sink name:%{public}s, move type:%{public}d", idStr.c_str(), name.c_str(), moveType); - TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + if (moveType == MOVE_ALL) { + TriggerSyncCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + } else { + TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType); + } } int32_t HpaeRendererManager::MoveAllStream(const std::string &sinkName, const std::vector& sessionIds, @@ -552,15 +578,7 @@ void HpaeRendererManager::MoveStreamSync(uint32_t sessionId, const std::string & AUDIO_INFO_LOG("[StartMove] session: %{public}u,sink [%{public}s] --> [%{public}s]", sessionId, sinkInfo_.deviceName.c_str(), sinkName.c_str()); std::shared_ptr inputNode = sinkInputNodeMap_[sessionId]; - HpaeSessionState inputState = inputNode->GetState(); - if (inputState == HPAE_SESSION_STOPPING || inputState == HPAE_SESSION_PAUSING) { - HpaeSessionState state = inputState == HPAE_SESSION_PAUSING ? HPAE_SESSION_PAUSED : HPAE_SESSION_STOPPED; - IOperation operation = inputState == HPAE_SESSION_PAUSING ? OPERATION_PAUSED : OPERATION_STOPPED; - SetSessionState(sessionId, state); - inputNode->SetState(state); - TriggerCallback(UPDATE_STATUS, HPAE_STREAM_CLASS_TYPE_PLAY, sessionId, state, operation); - // todo: do fade out - } + TriggerStreamState(sessionId, inputNode); DeleteInputSessionForMove(sessionId); std::string name = sinkName; TriggerCallback(MOVE_SINK_INPUT, inputNode, name); @@ -648,7 +666,7 @@ void HpaeRendererManager::OnDisConnectProcessCluster(HpaeProcessorType sceneType } toBeStoppedSceneTypeToSessionMap_.erase(sceneType); } - DeleteProcessCluster(sceneType); + DeleteProcessClusterInner(sceneType); }; SendRequest(request); } @@ -817,6 +835,7 @@ int32_t HpaeRendererManager::ReloadRenderManager(const HpaeSinkInfo &sinkInfo, b AUDIO_INFO_LOG("ReloadRenderManager deviceName %{public}s", sinkInfo.deviceName.c_str()); for (const auto &it : sinkInputNodeMap_) { + TriggerStreamState(it.first, it.second); DeleteConnectInputProcessor(it.second); } AUDIO_INFO_LOG("delete device:%{public}s all input processor end", sinkInfo.deviceName.c_str()); @@ -1395,6 +1414,18 @@ int32_t HpaeRendererManager::HandleSyncId(uint32_t sessionId, int32_t syncId) } return outputCluster_->SetSyncId(syncId); } + +void HpaeRendererManager::TriggerStreamState(uint32_t sessionId, const std::shared_ptr &inputNode) +{ + HpaeSessionState inputState = inputNode->GetState(); + if (inputState == HPAE_SESSION_STOPPING || inputState == HPAE_SESSION_PAUSING) { + HpaeSessionState state = inputState == HPAE_SESSION_PAUSING ? HPAE_SESSION_PAUSED : HPAE_SESSION_STOPPED; + IOperation operation = inputState == HPAE_SESSION_PAUSING ? OPERATION_PAUSED : OPERATION_STOPPED; + SetSessionState(sessionId, state); + inputNode->SetState(state); + TriggerCallback(UPDATE_STATUS, HPAE_STREAM_CLASS_TYPE_PLAY, sessionId, state, operation); + } +} } // namespace HPAE } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_engine/node/include/hpae_mixer_node.h b/services/audio_engine/node/include/hpae_mixer_node.h index b6e36a15fbc3d5b001036400bb747e7a1336323d..15f892f885e1f07251133548b9789acf4e659f17 100644 --- a/services/audio_engine/node/include/hpae_mixer_node.h +++ b/services/audio_engine/node/include/hpae_mixer_node.h @@ -31,6 +31,7 @@ public: virtual bool Reset() override; int32_t SetupAudioLimiter(); int32_t InitAudioLimiter(); + virtual void SetNodeInfo(HpaeNodeInfo& nodeInfo) override; protected: HpaePcmBuffer *SignalProcess(const std::vector &inputs) override; private: diff --git a/services/audio_engine/node/include/hpae_output_cluster.h b/services/audio_engine/node/include/hpae_output_cluster.h index 94517dc541b82e2e165023566c3d215b9bbea2a6..37820f8df09bbdaede06ee7b0353444de7df700b 100644 --- a/services/audio_engine/node/include/hpae_output_cluster.h +++ b/services/audio_engine/node/include/hpae_output_cluster.h @@ -32,6 +32,7 @@ public: bool ResetAll() override; void Connect(const std::shared_ptr> &preNode) override; void DisConnect(const std::shared_ptr> &preNode) override; + void RegisterCurrentDeviceCallback(); int32_t GetConverterNodeCount() override; int32_t GetPreOutNum() override; int32_t GetInstance(const std::string &deviceClass, const std::string &deviceNetId) override; @@ -55,6 +56,7 @@ private: std::shared_ptr mixerNode_ = nullptr; std::shared_ptr hpaeSinkOutputNode_ = nullptr; std::unordered_map> sceneConverterMap_; + std::atomic timeoutThdFramesForDevice_ = TIME_OUT_STOP_THD_DEFAULT_FRAME; uint32_t timeoutThdFrames_ = TIME_OUT_STOP_THD_DEFAULT_FRAME; uint32_t timeoutStopCount_ = 0; uint32_t frameLenMs_ = FRAME_LEN_MS_DEFAULT_MS; diff --git a/services/audio_engine/node/include/hpae_remote_output_cluster.h b/services/audio_engine/node/include/hpae_remote_output_cluster.h index 72beca137c6203566d5b879639664f7373fd92a8..6621d87bddb3b7bfffc7b09888b0a7ae84182a18 100644 --- a/services/audio_engine/node/include/hpae_remote_output_cluster.h +++ b/services/audio_engine/node/include/hpae_remote_output_cluster.h @@ -51,6 +51,7 @@ public: StreamManagerState GetState(void) override; bool IsProcessClusterConnected(HpaeProcessorType sceneType) override; int32_t UpdateAppsUid(const std::vector &appsUid) override; + void UpdateStreamInfo(const std::shared_ptr> preNode) override; private: std::shared_ptr hpaeSinkOutputNode_ = nullptr; std::unordered_map> sceneConverterMap_; diff --git a/services/audio_engine/node/include/hpae_sink_output_node.h b/services/audio_engine/node/include/hpae_sink_output_node.h index e6e82b63ec766a3bba75986823d6766179a97826..04cd26dae47035295033ebc3f9b547e0e21f59b5 100644 --- a/services/audio_engine/node/include/hpae_sink_output_node.h +++ b/services/audio_engine/node/include/hpae_sink_output_node.h @@ -39,6 +39,7 @@ public: virtual bool ResetAll() override; void Connect(const std::shared_ptr> &preNode) override; void DisConnect(const std::shared_ptr> &preNode) override; + void RegisterCurrentDeviceCallback(const std::function &callback); int32_t GetRenderSinkInstance(const std::string &deviceClass, const std::string &deviceNetId); int32_t RenderSinkInit(IAudioSinkAttr &attr); int32_t RenderSinkDeInit(); diff --git a/services/audio_engine/node/include/i_hpae_output_cluster.h b/services/audio_engine/node/include/i_hpae_output_cluster.h index 702da2088f7efa7ffd182d69ca2c3ae5b0cfeafb..feb2fdce9cad270b7c607f90c464c33e530bc8f5 100644 --- a/services/audio_engine/node/include/i_hpae_output_cluster.h +++ b/services/audio_engine/node/include/i_hpae_output_cluster.h @@ -45,6 +45,7 @@ public: virtual int32_t SetPriPaPower(void) { return 0; }; virtual int32_t SetSyncId(int32_t syncId) { return 0; }; virtual uint32_t GetLatency() { return 0; }; + virtual void UpdateStreamInfo(const std::shared_ptr> preNode) {}; }; } // namespace HPAE } // namespace AudioStandard diff --git a/services/audio_engine/node/src/hpae_mixer_node.cpp b/services/audio_engine/node/src/hpae_mixer_node.cpp index 89a325fc1a67e0ef844eebf51532135aeb838bd1..16b2dbdb2f5ec723f23b5f55d3e741b1b53995d0 100644 --- a/services/audio_engine/node/src/hpae_mixer_node.cpp +++ b/services/audio_engine/node/src/hpae_mixer_node.cpp @@ -39,6 +39,7 @@ HpaeMixerNode::HpaeMixerNode(HpaeNodeInfo &nodeInfo) mixedOutput_(pcmBufferInfo_), tmpOutput_(pcmBufferInfo_) { mixedOutput_.SetSplitStreamType(nodeInfo.GetSplitStreamType()); + mixedOutput_.SetAudioStreamType(nodeInfo.streamType); #ifdef ENABLE_HIDUMP_DFX SetNodeName("hpaeMixerNode"); #endif @@ -57,6 +58,14 @@ bool HpaeMixerNode::Reset() return HpaePluginNode::Reset(); } +void HpaeMixerNode::SetNodeInfo(HpaeNodeInfo& nodeInfo) +{ + mixedOutput_.SetAudioStreamType(nodeInfo.streamType); + tmpOutput_.SetAudioStreamType(nodeInfo.streamType); + silenceData_.SetAudioStreamType(nodeInfo.streamType); + HpaeNode::SetNodeInfo(nodeInfo); +} + int32_t HpaeMixerNode::SetupAudioLimiter() { if (limiter_ != nullptr) { diff --git a/services/audio_engine/node/src/hpae_node_common.cpp b/services/audio_engine/node/src/hpae_node_common.cpp index fec096ba8b82c3c1e6221b65befb79db0c35ad05..c0ed5d1e3f99537311f946a60aed0c5b2b2cabaa 100644 --- a/services/audio_engine/node/src/hpae_node_common.cpp +++ b/services/audio_engine/node/src/hpae_node_common.cpp @@ -304,9 +304,11 @@ int32_t TransModuleInfoToHpaeSinkInfo(const AudioModuleInfo &audioModuleInfo, Hp } sinkInfo.deviceNetId = audioModuleInfo.networkId; sinkInfo.deviceClass = audioModuleInfo.className; - AUDIO_INFO_LOG("HpaeManager::deviceNetId: %{public}s, deviceClass: %{public}s", + sinkInfo.suspendTime = audioModuleInfo.suspendIdleTimeout; + AUDIO_INFO_LOG("HpaeManager::deviceNetId: %{public}s, deviceClass: %{public}s, suspend_time: %{public}u", sinkInfo.deviceNetId.c_str(), - sinkInfo.deviceClass.c_str()); + sinkInfo.deviceClass.c_str(), + sinkInfo.suspendTime); sinkInfo.adapterName = audioModuleInfo.adapterName; sinkInfo.lib = audioModuleInfo.lib; sinkInfo.splitMode = audioModuleInfo.extra; diff --git a/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp b/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp index 48330599df1e1c54b71c4ccfb97fb66312de8708..b4b93fcfda92371d56f4cc8d6ff9f9bac9ef313e 100644 --- a/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp +++ b/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp @@ -51,6 +51,7 @@ namespace { static constexpr float EPSILON = 1e-6f; const std::string DEVICE_CLASS_OFFLOAD = "offload"; + const std::string DEVICE_CLASS_REMOTE_OFFLOAD = "remote_offload"; } HpaeOffloadSinkOutputNode::HpaeOffloadSinkOutputNode(HpaeNodeInfo &nodeInfo) : HpaeNode(nodeInfo), @@ -416,6 +417,7 @@ int32_t HpaeOffloadSinkOutputNode::SetOffloadRenderCallbackType(int32_t type) void HpaeOffloadSinkOutputNode::SetSpeed(float speed) { CHECK_AND_RETURN_LOG(audioRendererSink_, "audioRendererSink_ is nullptr sessionId: %{public}u", GetSessionId()); + CHECK_AND_RETURN(GetStreamType() == STREAM_MOVIE || GetDeviceClass() == DEVICE_CLASS_REMOTE_OFFLOAD); speed_ = speed; audioRendererSink_->SetSpeed(speed); } diff --git a/services/audio_engine/node/src/hpae_output_cluster.cpp b/services/audio_engine/node/src/hpae_output_cluster.cpp index de18f955c0730dc2d851efb871adeb4cc56d0dbc..776cb9bd3ba08a8cdc77830d053f8ee81e3ce8a9 100644 --- a/services/audio_engine/node/src/hpae_output_cluster.cpp +++ b/services/audio_engine/node/src/hpae_output_cluster.cpp @@ -52,6 +52,18 @@ HpaeOutputCluster::~HpaeOutputCluster() #endif } +void HpaeOutputCluster::RegisterCurrentDeviceCallback() +{ + std::function callback = [=](bool isA2dp) { + if (isA2dp) { + timeoutThdFramesForDevice_ = TIME_OUT_STOP_THD_DEFAULT_FRAME; + } else { + timeoutThdFramesForDevice_ = timeoutThdFrames_; + } + }; + hpaeSinkOutputNode_->RegisterCurrentDeviceCallback(callback); +} + void HpaeOutputCluster::DoProcess() { Trace trace("HpaeOutputCluster::DoProcess"); @@ -61,7 +73,7 @@ void HpaeOutputCluster::DoProcess() } else { timeoutStopCount_ = 0; } - if (timeoutStopCount_ > timeoutThdFrames_) { + if (timeoutStopCount_ > timeoutThdFramesForDevice_) { int32_t ret = hpaeSinkOutputNode_->RenderSinkStop(); timeoutStopCount_ = 0; AUDIO_INFO_LOG("HpaeOutputCluster timeout RenderSinkStop ret :%{public}d", ret); @@ -145,6 +157,7 @@ int32_t HpaeOutputCluster::GetInstance(const std::string &deviceClass, const std int32_t HpaeOutputCluster::Init(IAudioSinkAttr &attr) { + RegisterCurrentDeviceCallback(); return hpaeSinkOutputNode_->RenderSinkInit(attr); } @@ -203,6 +216,7 @@ int32_t HpaeOutputCluster::SetTimeoutStopThd(uint32_t timeoutThdMs) if (frameLenMs_ != 0) { timeoutThdFrames_ = timeoutThdMs / frameLenMs_; } + timeoutThdFramesForDevice_ = timeoutThdFrames_; AUDIO_INFO_LOG( "SetTimeoutStopThd: timeoutThdFrames_:%{public}u, timeoutThdMs :%{public}u", timeoutThdFrames_, timeoutThdMs); return SUCCESS; diff --git a/services/audio_engine/node/src/hpae_plugin_node.cpp b/services/audio_engine/node/src/hpae_plugin_node.cpp index dd13ca468e086c7360394b130774943484423b7b..357789b95d4e6d83d40833ae0235d02089ecda0a 100644 --- a/services/audio_engine/node/src/hpae_plugin_node.cpp +++ b/services/audio_engine/node/src/hpae_plugin_node.cpp @@ -28,6 +28,7 @@ HpaePluginNode::HpaePluginNode(HpaeNodeInfo& nodeInfo) silenceData_.SetBufferValid(false); silenceData_.SetBufferSilence(true); silenceData_.SetSplitStreamType(nodeInfo.GetSplitStreamType()); + silenceData_.SetAudioStreamType(nodeInfo.streamType); } void HpaePluginNode::DoProcess() diff --git a/services/audio_engine/node/src/hpae_process_cluster.cpp b/services/audio_engine/node/src/hpae_process_cluster.cpp index 98898994abf8543c81ef40999bc8a2ca248d280e..c4fd9686a8c5681a7d6fee8b6cfd8236f60a8ae3 100644 --- a/services/audio_engine/node/src/hpae_process_cluster.cpp +++ b/services/audio_engine/node/src/hpae_process_cluster.cpp @@ -191,6 +191,10 @@ void HpaeProcessCluster::Connect(const std::shared_ptrConnect(idLoudnessGainNodeMap_[sessionId]); idLoudnessGainNodeMap_[sessionId]->Connect(idConverterMap_[sessionId]); idConverterMap_[sessionId]->Connect(preNode); + // update mixer node info + HpaeNodeInfo tmpNodeinfo = mixerNode_->GetNodeInfo(); + tmpNodeinfo.streamType = preNodeInfo.streamType; + mixerNode_->SetNodeInfo(tmpNodeinfo); mixerNode_->EnableProcess(true); } diff --git a/services/audio_engine/node/src/hpae_remote_output_cluster.cpp b/services/audio_engine/node/src/hpae_remote_output_cluster.cpp index 7f4205fc51611c74855502e12fa962c3962f6629..be2b094d9504e29d628d2eee4ce6f6930a5fffe6 100644 --- a/services/audio_engine/node/src/hpae_remote_output_cluster.cpp +++ b/services/audio_engine/node/src/hpae_remote_output_cluster.cpp @@ -108,6 +108,7 @@ void HpaeRemoteOutputCluster::Connect(const std::shared_ptr(preNodeInfo, nodeInfo); } @@ -118,9 +119,27 @@ void HpaeRemoteOutputCluster::Connect(const std::shared_ptrConnect(sceneConverterMap_[sceneType]); sceneConverterMap_[sceneType]->Connect(preNode); + UpdateStreamInfo(preNode); connectedProcessCluster_.insert(sceneType); } +void HpaeRemoteOutputCluster::UpdateStreamInfo(const std::shared_ptr> preNode) +{ + HpaeNodeInfo &preNodeInfo = preNode->GetSharedInstance()->GetNodeInfo(); + HpaeProcessorType sceneType = preNodeInfo.sceneType; + // update mixed node streamType + HpaeNodeInfo tmpNodeInfo = sceneMixerMap_[sceneType]->GetNodeInfo(); + tmpNodeInfo.streamType = preNodeInfo.streamType; + sceneMixerMap_[sceneType]->SetNodeInfo(tmpNodeInfo); + // update convert node streamType + tmpNodeInfo = sceneConverterMap_[sceneType]->GetNodeInfo(); + tmpNodeInfo.streamType = preNodeInfo.streamType; + sceneConverterMap_[sceneType]->SetNodeInfo(tmpNodeInfo); + AUDIO_INFO_LOG("update stream info %{public}d type %{public}d", + sceneMixerMap_[sceneType]->GetNodeInfo().nodeId, + sceneMixerMap_[sceneType]->GetNodeInfo().streamType); +} + void HpaeRemoteOutputCluster::DisConnect(const std::shared_ptr> &preNode) { HpaeNodeInfo &preNodeInfo = preNode->GetSharedInstance()->GetNodeInfo(); diff --git a/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp b/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp index 206a7e2c2f5b23ab38948002270d0015b75cc251..46bc7531410513050730bb7cf14aa16e29c3e315 100644 --- a/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp +++ b/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp @@ -115,6 +115,7 @@ void HpaeRemoteSinkOutputNode::DoProcess() continue; } HpaeSplitStreamType streamType = outputData->GetSplitStreamType(); + AudioStreamType type = outputData->GetAudioStreamType(); ConvertFromFloat( GetBitWidth(), GetChannelCount() * GetFrameLen(), outputData->GetPcmDataBuffer(), renderFrameData_.data()); uint64_t writeLen = 0; @@ -123,7 +124,8 @@ void HpaeRemoteSinkOutputNode::DoProcess() HandlePcmDumping(streamType, renderFrameData, renderFrameData_.size()); #endif auto ret = audioRendererSink_->SplitRenderFrame(*renderFrameData, renderFrameData_.size(), - writeLen, std::to_string(static_cast(streamType)).c_str()); + writeLen, std::to_string(static_cast(streamType)).c_str(), + std::to_string(static_cast(type)).c_str()); if (ret != SUCCESS || writeLen != renderFrameData_.size()) { AUDIO_ERR_LOG("HpaeRemoteSinkOutputNode: RenderFrame failed, SplitStreamType %{public}d", streamType); } diff --git a/services/audio_engine/node/src/hpae_sink_output_node.cpp b/services/audio_engine/node/src/hpae_sink_output_node.cpp index 8bb79055b4caaa5754ffd2d030fce8f52fe49f8c..6e1838019342cf5baa6771651731f150a1ae2107 100644 --- a/services/audio_engine/node/src/hpae_sink_output_node.cpp +++ b/services/audio_engine/node/src/hpae_sink_output_node.cpp @@ -123,6 +123,13 @@ const char *HpaeSinkOutputNode::GetRenderFrameData(void) return renderFrameData_.data(); } +void HpaeSinkOutputNode::RegisterCurrentDeviceCallback(const std::function &callback) +{ + CHECK_AND_RETURN_LOG(audioRendererSink_ != nullptr, "audioRendererSink_ is nullptr"); + CHECK_AND_RETURN_LOG(callback != nullptr, "callback is nullptr"); + audioRendererSink_->RegisterCurrentDeviceCallback(callback); +} + bool HpaeSinkOutputNode::Reset() { const auto preOutputMap = inputStream_.GetPreOutputMap(); diff --git a/services/audio_engine/test/unittest/node/hpae_output_cluster_test.cpp b/services/audio_engine/test/unittest/node/hpae_output_cluster_test.cpp index 2b8c5ee506507737da2af33d4ed1d0c0c822ea85..e63bfe598d679026f5acbb5f710b316e9d4eeee5 100644 --- a/services/audio_engine/test/unittest/node/hpae_output_cluster_test.cpp +++ b/services/audio_engine/test/unittest/node/hpae_output_cluster_test.cpp @@ -159,6 +159,7 @@ HWTEST_F(HpaeOutputClusterTest, testHpaeWriteDataOutSessionTest, TestSize.Level0 std::shared_ptr writeFixedValueCb1 = std::make_shared(SAMPLE_F32LE, TEST_VALUE_2); ringSinkInputNode->RegisterWriteCallback(writeFixedValueCb1); + hpaeOutputCluster->RegisterCurrentDeviceCallback(); hpaeOutputCluster->DoProcess(); TestRendererRenderFrame(hpaeOutputCluster->GetFrameData(), nodeInfo.frameLen * nodeInfo.channels * GetSizeFromFormat(nodeInfo.format)); diff --git a/services/audio_engine/test/unittest/node/hpae_sink_output_node_test.cpp b/services/audio_engine/test/unittest/node/hpae_sink_output_node_test.cpp index 05c744a32da9ac0ac3becd0fdbd3c0a01c588bbf..393686a0e7dd02b6a2df0b74ea76f25c34039f3c 100644 --- a/services/audio_engine/test/unittest/node/hpae_sink_output_node_test.cpp +++ b/services/audio_engine/test/unittest/node/hpae_sink_output_node_test.cpp @@ -119,7 +119,7 @@ public: int32_t UnLockOffloadRunningLock() override { return -1; } int32_t SplitRenderFrame(char & /* data */, uint64_t /* len */, uint64_t & /* writeLen */, - const char * /* streamType */) override { return -1; } + const char * /* streamType */, const char * /* audioType */) override { return -1; } int32_t UpdatePrimaryConnectionState(uint32_t /* operation */) override { return -1; } @@ -208,6 +208,8 @@ HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutConnectNode, TestSize.Level0) EXPECT_EQ(hpaeSinkInputNode.use_count(), usedCount); hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode); EXPECT_EQ(hpaeSinkInputNode.use_count(), 1); + std::function callback = [](bool state) { EXPECT_FALSE(state); }; + hpaeSinkOutputNode->RegisterCurrentDeviceCallback(callback); hpaeSinkOutputNode->RenderSinkDeInit(); } @@ -254,6 +256,8 @@ HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutConnectNodeRemote, TestSize.Leve EXPECT_EQ(hpaeSinkInputNode.use_count(), usedCount); hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode); EXPECT_EQ(hpaeSinkInputNode.use_count(), 1); + std::function callback = [](bool state) { EXPECT_FALSE(state); }; + hpaeSinkOutputNode->RegisterCurrentDeviceCallback(callback); hpaeSinkOutputNode->RenderSinkDeInit(); } @@ -299,6 +303,8 @@ HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutHandlePaPower, TestSize.Level0) hpaeSinkOutputNode->isOpenPaPower_ = false; hpaeSinkOutputNode->silenceDataUs_ = 500000000; // 500000000 us, long silence time hpaeSinkOutputNode->HandlePaPower(outputData); + std::function callback = [](bool state) { EXPECT_FALSE(state); }; + hpaeSinkOutputNode->RegisterCurrentDeviceCallback(callback); hpaeSinkOutputNode->RenderSinkDeInit(); } @@ -363,6 +369,8 @@ HWTEST_F(HpaeSinkOutputNodeTest, testDoProcessAfterResetPcmDumper, TestSize.Leve hpaeSinkOutputNode->RenderSinkInit(attr); hpaeSinkOutputNode->RenderSinkStart(); hpaeSinkOutputNode->DoProcess(); + std::function callback = [](bool state) { EXPECT_FALSE(state); }; + hpaeSinkOutputNode->RegisterCurrentDeviceCallback(callback); hpaeSinkOutputNode->RenderSinkDeInit(); } #endif @@ -410,6 +418,8 @@ HWTEST_F(HpaeSinkOutputNodeTest, testHpaeSinkOutHandleHapticParam, TestSize.Leve EXPECT_EQ(hpaeSinkInputNode.use_count(), usedCount); hpaeSinkOutputNode->DisConnect(hpaeSinkInputNode); EXPECT_EQ(hpaeSinkInputNode.use_count(), 1); + std::function callback = [](bool state) { EXPECT_FALSE(state); }; + hpaeSinkOutputNode->RegisterCurrentDeviceCallback(callback); hpaeSinkOutputNode->RenderSinkDeInit(); } } // namespace HPAE diff --git a/services/audio_policy/BUILD.gn b/services/audio_policy/BUILD.gn index dd2b745f3789e2c17698dc9fbbb3bd7599c8b578..cba57a80c58d5c6f4b201f02a21f336e3ce79102 100644 --- a/services/audio_policy/BUILD.gn +++ b/services/audio_policy/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("../../accessibility.gni") import("../../appgallery.gni") import("../../audio_framework_test_sources.gni") -import("../../av_session.gni") import("../../bluetooth_part.gni") import("../../config.gni") @@ -111,10 +110,6 @@ config("audio_policy_public_config") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true && !(use_libfuzzer || use_clang_coverage)) { - cflags += [ "-DAVSESSION_ENABLE" ] - } - ldflags = [ "-Wl" ] } @@ -200,6 +195,7 @@ audio_ohos_library("audio_policy_service") { "server/infra/config/parser/src/audio_policy_config_parser.cpp", "server/infra/config/parser/src/audio_policy_global_parser.cpp", "server/infra/config/parser/src/audio_strategy_router_parser.cpp", + "server/infra/config/parser/src/audio_source_strategy_parser.cpp", "server/infra/config/parser/src/audio_usage_strategy_parser.cpp", "server/infra/config/parser/src/audio_volume_parser.cpp", "server/infra/datashare/src/audio_policy_utils.cpp", @@ -619,16 +615,24 @@ group("audio_policy_test_packages") { ":audio_policy_test", "test:audio_policy_unittest_packages", "client/stub:audio_zone_client_unit_test", + "client/stub:audio_policy_manager_listener_stub_impl_unit_test", + "client/service/test:audio_policy_manager_device_unit_test", "server/infra/config/parser/test:audio_policy_config_parser_unittest_packages", "server/domain/device:audio_device_common_unit_next_test", "server/domain/device/test:audio_device_status_extended_test", "server/domain/effect/test:audio_spatialization_service_extended_test", + "server/domain/pipe/test:audio_policy_pipe_unittest_packages", + "server/domain/router/test:audio_router_unittest_packages", + "server/domain/session/test:audio_policy_session_unit_test", + "server/domain/volume/test:audio_volume_unittest_packages", "server/service/service_main/test:audio_policy_dump_unit_test", "server/service/service_main/test:audio_policy_server_extended_test", "server/service/service_main/test:audio_policy_service_ext_unit_test", "server/service/service_main/test:device_init_callback_unit_test", "server/infra/state_monitor/test:audio_policy_state_monitor_unittest_packages", + "server/infra/ipc_proxy/test:audio_policy_ipc_proxy_unittest_packages", "server/common/test:audio_policy_server_common_unittest_packages", + "server/src/test:audio_server_src_unittest_packages", ] } diff --git a/services/audio_policy/client/service/src/audio_policy_manager_device.cpp b/services/audio_policy/client/service/src/audio_policy_manager_device.cpp index 6521e5d803b485fbb40ace4db98365efe9f225f8..09dcfb30f0621e10b5e557288ffa778dadc0c573 100644 --- a/services/audio_policy/client/service/src/audio_policy_manager_device.cpp +++ b/services/audio_policy/client/service/src/audio_policy_manager_device.cpp @@ -563,13 +563,6 @@ int32_t AudioPolicyManager::UnsetAudioDeviceAnahsCallback() return gsp->UnsetAudioDeviceAnahsCallback(); } -int32_t AudioPolicyManager::MoveToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType) -{ - const sptr gsp = GetAudioPolicyManagerProxy(); - CHECK_AND_RETURN_RET_LOG(gsp != nullptr, ERROR, "audio policy manager proxy is NULL."); - return gsp->MoveToNewPipe(sessionId, pipeType); -} - int32_t AudioPolicyManager::SetDeviceVolumeBehavior(const std::string &networkId, DeviceType deviceType, VolumeBehavior volumeBehavior) { diff --git a/services/audio_policy/client/service/test/BUILD.gn b/services/audio_policy/client/service/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..05eb8c307715b7c1c89623481ccce35821e66911 --- /dev/null +++ b/services/audio_policy/client/service/test/BUILD.gn @@ -0,0 +1,116 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../accessibility.gni") +import("../../../../../appgallery.gni") +import("../../../../../bluetooth_part.gni") +import("../../../../../config.gni") + +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +ohos_unittest("audio_policy_manager_device_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./audio_policy_manager_device_unit_test/include", + "../../../../audio_policy/server/domain/interrupt/include", + "../../../../audio_policy/server/src/service/service", + "../../../../audio_policy/server/include", + "../../../../audio_policy/server/src", + "../../../../audio_policy/server/src/interface", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + cflags_cc = cflags + + sanitize = { + cfi = true + cfi_cross_dso = true + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = true + } + + external_deps = [ + "bluetooth:btframework", + "common_event_service:cesfwk_innerkits", + "googletest:gmock", + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "pulseaudio:pulse", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", + "ability_runtime:wantagent_innerkits", + ] + + sources = [ + "./audio_policy_manager_device_unit_test/src/audio_policy_manager_device_unit_test.cpp", + "../../service/src/audio_policy_manager.cpp", + "../../service/src/audio_policy_manager_device.cpp", + "../../stub/src/audio_zone_client.cpp", + "../../../../audio_policy/server/domain/zone/src/audio_zone_service.cpp", + "../../stub/src/audio_policy_client_stub_impl.cpp", + ] + + deps = [ + "../../../../../services/audio_service/idl:audio_framework_interface", + "../../../../audio_policy:audio_policy_service_static", + ] +} \ No newline at end of file diff --git a/services/audio_policy/client/service/test/audio_policy_manager_device_unit_test/include/audio_policy_manager_device_unit_test.h b/services/audio_policy/client/service/test/audio_policy_manager_device_unit_test/include/audio_policy_manager_device_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..9c73e78c716d65d9b69b6fe70527ca32d0625e02 --- /dev/null +++ b/services/audio_policy/client/service/test/audio_policy_manager_device_unit_test/include/audio_policy_manager_device_unit_test.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2021-2024 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_POLICY_MANAGER_DEVICE_UNIT_TEST_H +#define AUDIO_POLICY_MANAGER_DEVICE_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_policy_manager.h" +#include "audio_server_death_recipient.h" +#include "audio_policy_log.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace AudioStandard { +class AudioManagerDeviceChangeCallbackTest : public AudioManagerDeviceChangeCallback { + virtual void OnDeviceChange(const DeviceChangeAction &deviceChangeAction) override {} +}; +class AudioPreferredInputDeviceChangeCallbackTest : public AudioPreferredInputDeviceChangeCallback { +public: + virtual ~AudioPreferredInputDeviceChangeCallbackTest() = default; + virtual void OnPreferredInputDeviceUpdated(const std::vector> &desc) {} +}; + +class AudioPreferredOutputDeviceChangeCallbackTest : public AudioPreferredOutputDeviceChangeCallback { +public: + virtual ~AudioPreferredOutputDeviceChangeCallbackTest() = default; + virtual void OnPreferredOutputDeviceUpdated(const std::vector> &desc) {} +}; + +class ConcreteDeviceChangeWithInfoCallback : public DeviceChangeWithInfoCallback { + void OnDeviceChangeWithInfo(const uint32_t sessionId, const AudioDeviceDescriptor &deviceInfo, + const AudioStreamDeviceChangeReasonExt reason) override {} + void OnRecreateStreamEvent( + const uint32_t sessionId, const int32_t streamFlag, const AudioStreamDeviceChangeReasonExt reason) override {} +}; + +class AudioPolicyManagerDeviceUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_POLICY_MANAGER_DEVICE_UNIT_TEST_H diff --git a/services/audio_policy/client/service/test/audio_policy_manager_device_unit_test/src/audio_policy_manager_device_unit_test.cpp b/services/audio_policy/client/service/test/audio_policy_manager_device_unit_test/src/audio_policy_manager_device_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5e4550ea4b123fcc600e3382129008edaacbbf60 --- /dev/null +++ b/services/audio_policy/client/service/test/audio_policy_manager_device_unit_test/src/audio_policy_manager_device_unit_test.cpp @@ -0,0 +1,235 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_errors.h" +#include "audio_policy_manager_device_unit_test.h" +#include "audio_utils.h" +#include "audio_device_status.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void AudioPolicyManagerDeviceUnitTest::SetUpTestCase(void) {} +void AudioPolicyManagerDeviceUnitTest::TearDownTestCase(void) {} +void AudioPolicyManagerDeviceUnitTest::SetUp(void) {} +void AudioPolicyManagerDeviceUnitTest::TearDown(void) {} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: SelectOutputDevice_001. +* @tc.desc : Test SelectOutputDevice. +*/ +HWTEST(AudioPolicyManagerDevice, SelectOutputDevice_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + sptr audioRendererFilter = new(std::nothrow) AudioRendererFilter(); + std::vector> descriptors; + for (int i = 0; i < 21; ++i) { + descriptors.push_back(std::make_shared()); + } + int32_t ret = audioPolicyManager_->SelectOutputDevice(audioRendererFilter, descriptors); + EXPECT_EQ(ret, -1); + descriptors.clear(); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: SelectOutputDevice_002. +* @tc.desc : Test SelectOutputDevice. +*/ +HWTEST(AudioPolicyManagerDevice, SelectOutputDevice_002, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + sptr audioRendererFilter = new(std::nothrow) AudioRendererFilter(); + std::vector> descriptors; + int32_t ret = audioPolicyManager_->SelectOutputDevice(audioRendererFilter, descriptors); + EXPECT_EQ(ret, -1); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: GetSelectedDeviceInfo_001. +* @tc.desc : Test GetSelectedDeviceInfo. +*/ +HWTEST(AudioPolicyManagerDevice, GetSelectedDeviceInfo_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + EXPECT_NE(audioPolicyManager_, nullptr); + auto ret = audioPolicyManager_->GetSelectedDeviceInfo(0, 0, AudioStreamType::STREAM_VOICE_CALL); + EXPECT_NE(ret, "test"); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: SelectInputDevice_001. +* @tc.desc : Test SelectInputDevice. +*/ +HWTEST(AudioPolicyManagerDevice, SelectInputDevice_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + EXPECT_NE(audioPolicyManager_, nullptr); + sptr audioCapturerFilter = new(std::nothrow) AudioCapturerFilter(); + std::vector> descriptors; + for (int i = 0; i < 5; ++i) { + descriptors.push_back(std::make_shared()); + } + int32_t ret = audioPolicyManager_->SelectInputDevice(audioCapturerFilter, descriptors); + EXPECT_NE(ret, SUCCESS); + descriptors.clear(); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: GetExcludedDevices_001. +* @tc.desc : Test GetExcludedDevices. +*/ +HWTEST(AudioPolicyManagerDevice, GetExcludedDevices_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + EXPECT_NE(audioPolicyManager_, nullptr); + auto ret = audioPolicyManager_->GetExcludedDevices(AudioDeviceUsage::MEDIA_OUTPUT_DEVICES); + EXPECT_NE(ret.size(), 5); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: GetDevicesInner_001. +* @tc.desc : Test GetDevicesInner. +*/ +HWTEST(AudioPolicyManagerDevice, GetDevicesInner_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + EXPECT_NE(audioPolicyManager_, nullptr); + auto ret = audioPolicyManager_->GetDevicesInner(DeviceFlag::OUTPUT_DEVICES_FLAG); + EXPECT_NE(ret.size(), 5); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: TriggerFetchDevice_001. +* @tc.desc : Test TriggerFetchDevice. +*/ +HWTEST(AudioPolicyManagerDevice, TriggerFetchDevice_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + EXPECT_NE(audioPolicyManager_, nullptr); + AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN; + int32_t ret = audioPolicyManager_->TriggerFetchDevice(reason); + EXPECT_NE(ret, SUCCESS); +} + +/** +* @tc.name : Test AudioPolicyManagerDevice. +* @tc.number: GetDmDeviceType_001. +* @tc.desc : Test GetDmDeviceType. +*/ +HWTEST(AudioPolicyManagerDevice, GetDmDeviceType_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + auto& deviceStatus = AudioDeviceStatus::GetInstance(); + deviceStatus.dmDeviceType_ = DEVICE_TYPE_INVALID; + int32_t result = audioPolicyManager_->GetDmDeviceType(); + EXPECT_EQ(result, DEVICE_TYPE_INVALID); +} + +/** + * @tc.name : Test AudioPolicyManagerDevice. + * @tc.number: UnsetDeviceChangeCallback_001. + * @tc.desc : Test SetDeviceChangeCallback && UnsetDeviceChangeCallback. + */ +HWTEST(AudioPolicyManagerDevice, UnsetDeviceChangeCallback_001, TestSize.Level1) +{ + auto &policyManager = AudioPolicyManager::GetInstance(); + int32_t ret = 0; + auto cb = std::make_shared(); + ASSERT_NE(cb, nullptr); + auto basecb = static_cast>(cb); + policyManager.SetDeviceChangeCallback( + 42, INPUT_DEVICES_FLAG, std::make_shared()); + policyManager.SetDeviceChangeCallback( + 42, OUTPUT_DEVICES_FLAG, std::make_shared()); + policyManager.UnsetDeviceChangeCallback(42, INPUT_DEVICES_FLAG, basecb); + ASSERT_EQ(ret, SUCCESS); + policyManager.UnsetDeviceChangeCallback(42, OUTPUT_DEVICES_FLAG, basecb); + ASSERT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyManagerDevice. + * @tc.number: UnsetPreferredOutputDeviceChangeCallback_001. + * @tc.desc : Test SetPreferredOutputDeviceChangeCallback && UnsetPreferredOutputDeviceChangeCallback. + */ +HWTEST(AudioPolicyManagerDevice, UnsetPreferredOutputDeviceChangeCallback_001, TestSize.Level1) +{ + auto &policyManager = AudioPolicyManager::GetInstance(); + int32_t ret = 0; + auto rendererInfo = AudioRendererInfo(); + policyManager.SetPreferredOutputDeviceChangeCallback( + rendererInfo, std::make_shared()); + ASSERT_EQ(ret, SUCCESS); + auto cb = std::make_shared(); + policyManager.UnsetPreferredOutputDeviceChangeCallback(cb); + ASSERT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyManagerDevice. + * @tc.number: UnsetPreferredInputDeviceChangeCallback_002. + * @tc.desc : Test SetPreferredInputDeviceChangeCallback && UnsetPreferredInputDeviceChangeCallback. + */ +HWTEST(AudioPolicyManagerDevice, UnsetPreferredInputDeviceChangeCallback_002, TestSize.Level1) +{ + auto &policyManager = AudioPolicyManager::GetInstance(); + int32_t ret = 0; + auto captureInfo = AudioCapturerInfo(); + policyManager.SetPreferredInputDeviceChangeCallback( + captureInfo, std::make_shared()); + ASSERT_EQ(ret, SUCCESS); + policyManager.UnsetPreferredInputDeviceChangeCallback( + std::make_shared()); + ASSERT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyManagerDevice. + * @tc.number: UnregisterDeviceChangeWithInfoCallback_001. + * @tc.desc : Test RegisterDeviceChangeWithInfoCallback && UnregisterDeviceChangeWithInfoCallback. + */ +HWTEST(AudioPolicyManagerDevice, UnregisterDeviceChangeWithInfoCallback_001, TestSize.Level1) +{ + auto &policyManager = AudioPolicyManager::GetInstance(); + int32_t ret = 0; + auto cb = std::make_shared(); + std::weak_ptr deviceChangeWithInfoCallback(cb); + policyManager.RegisterDeviceChangeWithInfoCallback(42, deviceChangeWithInfoCallback); + ASSERT_EQ(ret, SUCCESS); + policyManager.UnregisterDeviceChangeWithInfoCallback(42); + ASSERT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyManagerDevice. + * @tc.number: GetAvailableDevices_001. + * @tc.desc : Test GetAvailableDevices(). + */ +HWTEST(AudioPolicyManagerDevice, GetAvailableDevices_001, TestSize.Level1) +{ + auto &policyManager = AudioPolicyManager::GetInstance(); + ASSERT_EQ((policyManager.GetAvailableDevices(MEDIA_INPUT_DEVICES)).size(), 1); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/client/stub/BUILD.gn b/services/audio_policy/client/stub/BUILD.gn index 7d3b0dfd07604d2142b4aa8a0d2b87b98b25bc84..f60489d9d00ee47675588926ce8cd89e41a077d1 100644 --- a/services/audio_policy/client/stub/BUILD.gn +++ b/services/audio_policy/client/stub/BUILD.gn @@ -68,6 +68,7 @@ ohos_unittest("audio_zone_client_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -128,4 +129,80 @@ ohos_unittest("audio_zone_client_unit_test") { [ "../../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] external_deps += [ "bluetooth:btframework" ] } +} + +ohos_unittest("audio_policy_manager_listener_stub_impl_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./test/audio_policy_manager_listener_stub_impl_unit_test/include", + "../stub/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "distributed_notification_service:ans_innerkits", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ + "./test/audio_policy_manager_listener_stub_impl_unit_test/src/audio_policy_manager_listener_stub_impl_unit_test.cpp" + ] + + deps = [ + "../../../audio_policy:audio_policy_client", + "../../../audio_policy:audio_policy_service_static", + "../../../audio_service:audio_client", + "../../../audio_service:audio_common", + ] } \ No newline at end of file diff --git a/services/audio_policy/client/stub/test/audio_policy_manager_listener_stub_impl_unit_test/include/audio_policy_manager_listener_stub_impl_unit_test.h b/services/audio_policy/client/stub/test/audio_policy_manager_listener_stub_impl_unit_test/include/audio_policy_manager_listener_stub_impl_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..5f3345c95570f8fdcdab885dd894b71d92e88e0a --- /dev/null +++ b/services/audio_policy/client/stub/test/audio_policy_manager_listener_stub_impl_unit_test/include/audio_policy_manager_listener_stub_impl_unit_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_POLICY_MANAGER_LISTENER_STUB_IMPL_UNIT_TEST_H +#define AUDIO_POLICY_MANAGER_LISTENER_STUB_IMPL_UNIT_TEST_H + +#include "audio_policy_manager_listener_stub_impl.h" +#include +#include + +namespace OHOS { +namespace AudioStandard { + +class AudioPolicyManagerListenerStubImplUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_POLICY_MANAGER_LISTENER_STUB_IMPL_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/client/stub/test/audio_policy_manager_listener_stub_impl_unit_test/src/audio_policy_manager_listener_stub_impl_unit_test.cpp b/services/audio_policy/client/stub/test/audio_policy_manager_listener_stub_impl_unit_test/src/audio_policy_manager_listener_stub_impl_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..500d82c8e7751ed96e7c96e93c9785c3cc692b01 --- /dev/null +++ b/services/audio_policy/client/stub/test/audio_policy_manager_listener_stub_impl_unit_test/src/audio_policy_manager_listener_stub_impl_unit_test.cpp @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_policy_manager_listener_stub_impl_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" + +#include +#include +#include + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +class MockAudioInterruptCallback : public AudioInterruptCallback { +public: + MOCK_METHOD(void, OnInterrupt, (const InterruptEventInternal&), (override)); +}; + +void AudioPolicyManagerListenerStubImplUnitTest::SetUpTestCase(void) {} +void AudioPolicyManagerListenerStubImplUnitTest::TearDownTestCase(void) {} +void AudioPolicyManagerListenerStubImplUnitTest::SetUp(void) {} +void AudioPolicyManagerListenerStubImplUnitTest::TearDown(void) {} + +/** + * @tc.name : Test AudioPolicyManagerListenerStubImpl. + * @tc.number: AudioPolicyManagerListenerStubImpl_001 + * @tc.desc : Test AudioPolicyManagerListenerStubImpl OnInterrupt interface. + */ +HWTEST(AudioPolicyManagerListenerStubImplUnitTest, AudioPolicyManagerListenerStubImpl_001, TestSize.Level4) +{ + AudioPolicyManagerListenerStubImpl stub; + InterruptEventInternal event{}; + int32_t ret = stub.OnInterrupt(event); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyManagerListenerStubImpl. + * @tc.number: AudioPolicyManagerListenerStubImpl_002 + * @tc.desc : Test AudioPolicyManagerListenerStubImpl OnInterrupt interface. + */ +HWTEST(AudioPolicyManagerListenerStubImplUnitTest, AudioPolicyManagerListenerStubImpl_002, TestSize.Level4) +{ + AudioPolicyManagerListenerStubImpl stub; + auto mockCb = std::make_shared(); + stub.SetInterruptCallback(std::weak_ptr(mockCb)); + InterruptEventInternal event{}; + EXPECT_CALL(*mockCb, OnInterrupt(_)).Times(1).WillOnce([&](const InterruptEventInternal& arg) { Return(); }); + int32_t ret = stub.OnInterrupt(event); + EXPECT_EQ(ret, SUCCESS); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/common/include/audio_module_info.h b/services/audio_policy/common/include/audio_module_info.h index 78d780391b4e6a8c0f912af0fd9b256eb458af38..232717ad2c18c6a83cb972d3d984d0f44d535c91 100644 --- a/services/audio_policy/common/include/audio_module_info.h +++ b/services/audio_policy/common/include/audio_module_info.h @@ -52,6 +52,7 @@ static const char* DP_SINK = "DP_speaker"; static const char* USB_MIC = "Usb_arm_mic"; static const char* PRIMARY_MIC = "Built_in_mic"; static const char* PRIMARY_WAKEUP_MIC = "Built_in_wakeup"; +static const char* PRIMARY_AI_MIC = "Built_in_ai"; static const char* FILE_SINK = "file_sink"; static const char* FILE_SOURCE = "file_source"; static const char* PIPE_SINK = "fifo_output"; @@ -136,6 +137,7 @@ struct AudioModuleInfo { std::string micRefRate; std::string micRefFormat; std::string micRefChannels; + uint32_t suspendIdleTimeout = DEFAULT_SUSPEND_TIME_IN_MS; std::list ports; std::string extra; diff --git a/services/audio_policy/common/include/audio_policy_ipc_interface_code.h b/services/audio_policy/common/include/audio_policy_ipc_interface_code.h index 1a2ad2b31dbbb9d3c8e9e8b5b3cef5a500378db6..e92dbc1eb359e79cfe89ca23b09ca81200e4480b 100644 --- a/services/audio_policy/common/include/audio_policy_ipc_interface_code.h +++ b/services/audio_policy/common/include/audio_policy_ipc_interface_code.h @@ -74,7 +74,6 @@ enum class AudioPolicyInterfaceCode { SELECT_OUTPUT_DEVICE, GET_SELECTED_DEVICE_INFO, SELECT_INPUT_DEVICE, - RECONFIGURE_CHANNEL, GET_PREFERRED_OUTPUT_STREAM_TYPE, GET_PREFERRED_INPUT_STREAM_TYPE, CREATE_RENDERER_CLIENT, @@ -174,7 +173,6 @@ enum class AudioPolicyInterfaceCode { SET_AUDIO_DEVICE_REFINER_CALLBACK, UNSET_AUDIO_DEVICE_REFINER_CALLBACK, TRIGGER_FETCH_DEVICE, - MOVE_TO_NEW_PIPE, DISABLE_SAFE_MEDIA_VOLUME, GET_DEVICES_INNER, SET_AUDIO_CONCURRENCY_CALLBACK, diff --git a/services/audio_policy/etc/audio_config.para b/services/audio_policy/etc/audio_config.para index cd55c048af6f48e627572d80074a5dd27e81c97b..1535cde3e757c7cc96b4c523bc6251309da36f17 100644 --- a/services/audio_policy/etc/audio_config.para +++ b/services/audio_policy/etc/audio_config.para @@ -17,4 +17,5 @@ persist.multimedia.audio.safevolume = 15 persist.multimedia.audio.safevolume.timeout = 1140 persist.multimedia.audio.firstboot = 1 const.multimedia.audio.proaudioEnable = 0 -const.multimedia.audio.anco_focus_control = 1 +persist.multimedia.audio.anco_focus_control = 1 +persist.multimedia.audio.anco_capture_focus_control = 1 diff --git a/services/audio_policy/etc/audio_config.para.dac b/services/audio_policy/etc/audio_config.para.dac index f955991ce0979ebdc21806dbdb3c12c691a84140..fd5d55341e6bde8423050f6d8c6127cc8c627e75 100644 --- a/services/audio_policy/etc/audio_config.para.dac +++ b/services/audio_policy/etc/audio_config.para.dac @@ -18,4 +18,5 @@ const.multimedia.audio.volumestep = audio:audio:660 persist.multimedia.audio.safevolume = audio:audio:660 persist.multimedia.audio.safevolume.timeout = audio:audio:660 persist.multimedia.audio.firstboot = audio:audio:660 -persist.multimedia.audio.anco_focus_control = audio:audio:660 \ No newline at end of file +persist.multimedia.audio.anco_focus_control = audio:audio:660 +persist.multimedia.audio.anco_capture_focus_control = audio:audio:660 diff --git a/services/audio_policy/idl/IAudioPolicy.idl b/services/audio_policy/idl/IAudioPolicy.idl index 5d0739940e7b6706598da171057161ff011f34d5..62b3c23018eb9ba89cac21d24f5bc75efa4539c4 100644 --- a/services/audio_policy/idl/IAudioPolicy.idl +++ b/services/audio_policy/idl/IAudioPolicy.idl @@ -187,7 +187,6 @@ interface IAudioPolicy { void ReleaseAudioZone([in] int zoneId); void GetAllAudioZone([out] List> retZoneDesc); void GetAudioZone([in] int zoneId, [out] sharedptr desc); - void GetAudioZoneByName([in] String name, [out] int zoneId); void BindDeviceToAudioZone([in] int zoneId, [in] List> devices); void UnBindDeviceToAudioZone([in] int zoneId, [in] List> devices); void EnableAudioZoneReport([in] boolean enable); @@ -195,9 +194,7 @@ interface IAudioPolicy { void AddUidToAudioZone([in] int zoneId, [in] int uid); void RemoveUidFromAudioZone([in] int zoneId, [in] int uid); void AddStreamToAudioZone([in] int zoneId, [in] AudioZoneStream stream); - void AddStreamsToAudioZone([in] int zoneId, [in] List streams); void RemoveStreamFromAudioZone([in] int zoneId, [in] AudioZoneStream stream); - void RemoveStreamsFromAudioZone([in] int zoneId, [in] List streams); void SetZoneDeviceVisible([in] boolean visible); void EnableSystemVolumeProxy([in] int zoneId, [in] boolean enable); void GetAudioInterruptForZone([in] int zoneId, [out] List> interrupts); @@ -219,7 +216,6 @@ interface IAudioPolicy { void SetAudioDeviceRefinerCallback([in] IRemoteObject object); void UnsetAudioDeviceRefinerCallback(); void TriggerFetchDevice([in] AudioStreamDeviceChangeReasonExt reason); - void MoveToNewPipe([in] unsigned int sessionId, [in] int pipeType); void DisableSafeMediaVolume(); void GetDevicesInner([in] int deviceFlag, [out] List> retDevicesList); void SetMicrophoneMutePersistent([in] boolean isMute, [in] int type); @@ -300,5 +296,8 @@ interface IAudioPolicy { void GetMinVolumeDegree([in] int volumeType, [out] int volumeDegree); // WARNING: above functions correspond with AudioPolicyInterfaceCode + void GetAudioZoneByName([in] String name, [out] int zoneId); + void AddStreamsToAudioZone([in] int zoneId, [in] List streams); + void RemoveStreamsFromAudioZone([in] int zoneId, [in] List streams); } diff --git a/services/audio_policy/server/common/test/BUILD.gn b/services/audio_policy/server/common/test/BUILD.gn index f0ee76a8f0e1a5671c99d1ca95839ae357ccd166..9c8fbae3b893b14a9ecc4ad9c4d7003ae0a06a90 100644 --- a/services/audio_policy/server/common/test/BUILD.gn +++ b/services/audio_policy/server/common/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../accessibility.gni") import("../../../../../appgallery.gni") -import("../../../../../av_session.gni") import("../../../../../bluetooth_part.gni") import("../../../../../config.gni") diff --git a/services/audio_policy/server/domain/device/BUILD.gn b/services/audio_policy/server/domain/device/BUILD.gn index 55b492263fde9029a13f400208436d7d8dec5e82..cd02eca14398a0156a37768c7b02a03e31bb469f 100644 --- a/services/audio_policy/server/domain/device/BUILD.gn +++ b/services/audio_policy/server/domain/device/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../accessibility.gni") import("../../../../../appgallery.gni") -import("../../../../../av_session.gni") import("../../../../../bluetooth_part.gni") import("../../../../../config.gni") diff --git a/services/audio_policy/server/domain/device/include/audio_active_device.h b/services/audio_policy/server/domain/device/include/audio_active_device.h index 6f53d52b233b37b51394b52c84755b1a78f53645..321b00008cfe23d3848dcc73b25dbcc38eb01d4f 100644 --- a/services/audio_policy/server/domain/device/include/audio_active_device.h +++ b/services/audio_policy/server/domain/device/include/audio_active_device.h @@ -23,16 +23,12 @@ #include #include "singleton.h" #include "audio_group_handle.h" -#include "audio_manager_base.h" #include "audio_module_info.h" #include "audio_volume_config.h" #include "audio_system_manager.h" #include "audio_errors.h" #include "audio_device_manager.h" #include "audio_affinity_manager.h" -#include "audio_policy_manager_factory.h" - - #include "audio_a2dp_offload_flag.h" #include "audio_a2dp_device.h" #include "audio_iohandle_map.h" @@ -40,6 +36,8 @@ namespace OHOS { namespace AudioStandard { +using InternalDeviceType = DeviceType; + class AudioActiveDevice { public: static AudioActiveDevice& GetInstance() @@ -47,7 +45,6 @@ public: static AudioActiveDevice instance; return instance; } - bool CheckActiveOutputDeviceSupportOffload(); bool IsDirectSupportedDevice(); void NotifyUserSelectionEventToBt(std::shared_ptr audioDeviceDescriptor, StreamUsage streamUsage = STREAM_USAGE_UNKNOWN); @@ -86,11 +83,10 @@ public: std::vector> descs); void UpdateStreamDeviceMap(std::string source); private: - AudioActiveDevice() : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), - audioDeviceManager_(AudioDeviceManager::GetAudioDeviceManager()), + AudioActiveDevice() + : audioDeviceManager_(AudioDeviceManager::GetAudioDeviceManager()), audioAffinityManager_(AudioAffinityManager::GetAudioAffinityManager()), audioA2dpDevice_(AudioA2dpDevice::GetInstance()), - audioIOHandleMap_(AudioIOHandleMap::GetInstance()), audioA2dpOffloadFlag_(AudioA2dpOffloadFlag::GetInstance()) {} ~AudioActiveDevice() {} void WriteOutputRouteChangeEvent(std::shared_ptr &desc, @@ -109,11 +105,9 @@ private: std::unordered_map> streamTypeDeviceMap_; std::unordered_map> streamUsageDeviceMap_; - IAudioPolicyInterface& audioPolicyManager_; AudioDeviceManager &audioDeviceManager_; AudioAffinityManager &audioAffinityManager_; AudioA2dpDevice& audioA2dpDevice_; - AudioIOHandleMap& audioIOHandleMap_; AudioA2dpOffloadFlag& audioA2dpOffloadFlag_; }; diff --git a/services/audio_policy/server/domain/device/include/audio_device_common.h b/services/audio_policy/server/domain/device/include/audio_device_common.h index 57e34d3232d955e1a4037227a1bb8116b844641d..67ecbb72becd05ecc0d6d1e1757f9cea97a53f55 100644 --- a/services/audio_policy/server/domain/device/include/audio_device_common.h +++ b/services/audio_policy/server/domain/device/include/audio_device_common.h @@ -98,8 +98,6 @@ public: std::vector> &rendererChangeInfos, const AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN); bool IsRendererStreamRunning(std::shared_ptr &rendererChangeInfo); - void FetchStreamForA2dpMchStream(std::shared_ptr &rendererChangeInfo, - vector> &descs); int32_t MoveToLocalOutputDevice(std::vector sinkInputIds, std::shared_ptr localDeviceDescriptor); @@ -147,10 +145,6 @@ private: void UpdateRoute(shared_ptr &rendererChangeInfo, std::vector> &outputDevices); - void FetchStreamForSpkMchStream(std::shared_ptr &rendererChangeInfo, - vector> &descs); - void ResetOffloadAndMchMode(std::shared_ptr &rendererChangeInfo, - vector> &outputDevices); bool SelectRingerOrAlarmDevices(const vector> &descs, const std::shared_ptr &rendererChangeInfo); bool IsSameDevice(std::shared_ptr &desc, AudioDeviceDescriptor &deviceInfo); @@ -159,7 +153,6 @@ private: bool IsDeviceConnected(std::shared_ptr &audioDeviceDescriptors) const; int32_t HandleDeviceChangeForFetchInputDevice(std::shared_ptr &desc, std::shared_ptr &capturerChangeInfo); - void JudgeIfLoadMchModule(); bool IsFastFromA2dpToA2dp(const std::shared_ptr &desc, const std::shared_ptr &rendererChangeInfo, const AudioStreamDeviceChangeReasonExt reason); diff --git a/services/audio_policy/server/domain/device/include/audio_device_manager.h b/services/audio_policy/server/domain/device/include/audio_device_manager.h index 378eab77dde5f14a600482f2e85d10017fff084c..774e7d6bde6d9dd5645536c87231ffc839472e3a 100644 --- a/services/audio_policy/server/domain/device/include/audio_device_manager.h +++ b/services/audio_policy/server/domain/device/include/audio_device_manager.h @@ -78,7 +78,7 @@ public: DeviceUsage GetDeviceUsage(const AudioDeviceDescriptor &desc); std::string GetConnDevicesStr(); bool IsArmUsbDevice(const AudioDeviceDescriptor &desc); - void OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName); + void OnReceiveUpdateDeviceNameEvent(const std::string macAddress, const std::string deviceName); bool IsDeviceConnected(std::shared_ptr &audioDeviceDescriptors); bool IsConnectedDevices(const std::shared_ptr &devDesc); bool IsVirtualConnectedDevice(const std::shared_ptr &selectedDesc); diff --git a/services/audio_policy/server/domain/device/src/audio_active_device.cpp b/services/audio_policy/server/domain/device/src/audio_active_device.cpp index d8896664be97e0c79dd3eb54dd32b5a795619efe..3fec386b98041cdbc8ee384e579d97ba6bd7e837 100644 --- a/services/audio_policy/server/domain/device/src/audio_active_device.cpp +++ b/services/audio_policy/server/domain/device/src/audio_active_device.cpp @@ -88,18 +88,6 @@ bool AudioActiveDevice::IsDirectSupportedDevice() return dev == DEVICE_TYPE_WIRED_HEADSET || dev == DEVICE_TYPE_USB_HEADSET; } -bool AudioActiveDevice::CheckActiveOutputDeviceSupportOffload() -{ - DeviceType dev = GetCurrentOutputDeviceType(); - if (GetCurrentOutputDeviceNetworkId() != LOCAL_NETWORK_ID || dev == DEVICE_TYPE_REMOTE_CAST) { - return false; - } - - return dev == DEVICE_TYPE_SPEAKER || - (dev == DEVICE_TYPE_BLUETOOTH_A2DP && audioA2dpOffloadFlag_.GetA2dpOffloadFlag() == A2DP_OFFLOAD) || - dev == DEVICE_TYPE_USB_HEADSET; -} - void AudioActiveDevice::SetCurrentInputDevice(const AudioDeviceDescriptor &desc) { std::lock_guard lock(curInputDevice_); diff --git a/services/audio_policy/server/domain/device/src/audio_device_common.cpp b/services/audio_policy/server/domain/device/src/audio_device_common.cpp index 30a168c68550597030dfa2db5f3b29c4a35330c8..8454c811ada35840c2867c4011f8c2d8abdc04a2 100644 --- a/services/audio_policy/server/domain/device/src/audio_device_common.cpp +++ b/services/audio_policy/server/domain/device/src/audio_device_common.cpp @@ -88,7 +88,8 @@ static const std::vector SourceNames = { std::string(BLUETOOTH_MIC), std::string(USB_MIC), std::string(PRIMARY_WAKEUP), - std::string(FILE_SOURCE) + std::string(FILE_SOURCE), + std::string(PRIMARY_AI_MIC) }; static bool IsDistributedOutput(const AudioDeviceDescriptor &desc) @@ -817,7 +818,6 @@ void AudioDeviceCommon::MoveToNewOutputDevice(std::shared_ptrclientUID, rendererChangeInfo->sessionId, rendererChangeInfo->outputDeviceInfo); - ResetOffloadAndMchMode(rendererChangeInfo, outputDevices); audioIOHandleMap_.NotifyUnmutePort(); } @@ -956,98 +956,6 @@ void AudioDeviceCommon::UpdateRoute(std::shared_ptr &re } } -void AudioDeviceCommon::ResetOffloadAndMchMode(std::shared_ptr &rendererChangeInfo, - vector> &outputDevices) -{ - if (outputDevices.front()->networkId_ != LOCAL_NETWORK_ID - || outputDevices.front()->deviceType_ == DEVICE_TYPE_REMOTE_CAST) { - audioOffloadStream_.RemoteOffloadStreamRelease(rendererChangeInfo->sessionId); - } else { - FetchStreamForSpkMchStream(rendererChangeInfo, outputDevices); - } -} - -void AudioDeviceCommon::JudgeIfLoadMchModule() -{ - bool isNeedLoadMchModule = false; - { - if (audioIOHandleMap_.CheckIOHandleExist(MCH_PRIMARY_SPEAKER) == false) { - isNeedLoadMchModule = true; - } - } - if (isNeedLoadMchModule) { - audioOffloadStream_.LoadMchModule(); - } -} - -void AudioDeviceCommon::FetchStreamForA2dpMchStream(std::shared_ptr &rendererChangeInfo, - vector> &descs) -{ - if (audioOffloadStream_.CheckStreamMultichannelMode(rendererChangeInfo->sessionId)) { - JudgeIfLoadMchModule(); - audioActiveDevice_.UpdateActiveDeviceRoute(DEVICE_TYPE_BLUETOOTH_A2DP, DeviceFlag::OUTPUT_DEVICES_FLAG); - std::string portName = AudioPolicyUtils::GetInstance().GetSinkPortName(descs.front()->deviceType_, - PIPE_TYPE_MULTICHANNEL); - int32_t ret = audioOffloadStream_.MoveToOutputDevice(rendererChangeInfo->sessionId, portName); - if (ret == SUCCESS) { - streamCollector_.UpdateRendererPipeInfo(rendererChangeInfo->sessionId, PIPE_TYPE_MULTICHANNEL); - } - } else { - AudioPipeType pipeType = PIPE_TYPE_UNKNOWN; - streamCollector_.GetPipeType(rendererChangeInfo->sessionId, pipeType); - if (pipeType == PIPE_TYPE_MULTICHANNEL) { - std::string currentActivePort = MCH_PRIMARY_SPEAKER; - AudioIOHandle activateDeviceIOHandle; - CHECK_AND_RETURN_LOG(audioIOHandleMap_.GetModuleIdByKey(currentActivePort, activateDeviceIOHandle), - "Can not find port MCH_PRIMARY_SPEAKER in io map"); - audioPolicyManager_.SuspendAudioDevice(currentActivePort, true); - audioPolicyManager_.CloseAudioPort(activateDeviceIOHandle); - audioIOHandleMap_.DelIOHandleInfo(currentActivePort); - streamCollector_.UpdateRendererPipeInfo(rendererChangeInfo->sessionId, PIPE_TYPE_NORMAL_OUT); - } - audioOffloadStream_.ResetOffloadMode(rendererChangeInfo->sessionId); - std::vector sinkInputs; - audioPolicyManager_.GetAllSinkInputs(sinkInputs); - MoveToNewOutputDevice(rendererChangeInfo, descs, sinkInputs); - } -} - -void AudioDeviceCommon::FetchStreamForSpkMchStream(std::shared_ptr &rendererChangeInfo, - vector> &descs) -{ - if (audioOffloadStream_.CheckStreamMultichannelMode(rendererChangeInfo->sessionId)) { - JudgeIfLoadMchModule(); - std::string oldSinkName = AudioPolicyUtils::GetInstance().GetSinkName(rendererChangeInfo->outputDeviceInfo, - rendererChangeInfo->sessionId); - std::string newSinkName = AudioPolicyUtils::GetInstance().GetSinkPortName(descs.front()->deviceType_, - PIPE_TYPE_MULTICHANNEL); - if (oldSinkName != newSinkName) { - AUDIO_INFO_LOG("mute sink old:[%{public}s] new:[%{public}s]", oldSinkName.c_str(), newSinkName.c_str()); - MuteSinkPort(oldSinkName, newSinkName, AudioStreamDeviceChangeReason::OVERRODE); - } - int32_t ret = audioOffloadStream_.MoveToOutputDevice(rendererChangeInfo->sessionId, newSinkName); - if (ret == SUCCESS) { - streamCollector_.UpdateRendererPipeInfo(rendererChangeInfo->sessionId, PIPE_TYPE_MULTICHANNEL); - } - } else { - AudioPipeType pipeType = PIPE_TYPE_UNKNOWN; - streamCollector_.GetPipeType(rendererChangeInfo->sessionId, pipeType); - if (pipeType == PIPE_TYPE_MULTICHANNEL) { - { - AUDIO_INFO_LOG("unload multichannel module"); - std::string currentActivePort = MCH_PRIMARY_SPEAKER; - AudioIOHandle activateDeviceIOHandle; - CHECK_AND_RETURN_LOG(audioIOHandleMap_.GetModuleIdByKey(currentActivePort, activateDeviceIOHandle), - "Can not find port MCH_PRIMARY_SPEAKER in io map"); - audioPolicyManager_.SuspendAudioDevice(currentActivePort, true); - audioPolicyManager_.CloseAudioPort(activateDeviceIOHandle); - audioIOHandleMap_.DelIOHandleInfo(currentActivePort); - } - } - audioOffloadStream_.ResetOffloadMode(rendererChangeInfo->sessionId); - } -} - bool AudioDeviceCommon::IsRingDualToneOnPrimarySpeaker(const vector> &descs, const int32_t sessionId) { @@ -1904,11 +1812,7 @@ void AudioDeviceCommon::SetFirstScreenOn() int32_t AudioDeviceCommon::SetVirtualCall(pid_t uid, const bool isVirtual) { - if (uid == 5523) { /* 5523 call manager */ - return Bluetooth::AudioHfpManager::SetVirtualCall("meetimeservice", isVirtual); - } - std::string bundleName = AudioBundleManager::GetBundleNameFromUid(uid); - return Bluetooth::AudioHfpManager::SetVirtualCall(bundleName, isVirtual); + return Bluetooth::AudioHfpManager::SetVirtualCall(uid, isVirtual); } void AudioDeviceCommon::SetHeadsetUnpluggedToSpkOrEpFlag(DeviceType oldDeviceType, DeviceType newDeviceType) diff --git a/services/audio_policy/server/domain/device/src/audio_device_descriptor.cpp b/services/audio_policy/server/domain/device/src/audio_device_descriptor.cpp index 6c03561608b61674a2a83e7199b6ea1c583db75c..f2a5c90ecf97023c8f5d714cd70e786ae15d1701 100644 --- a/services/audio_policy/server/domain/device/src/audio_device_descriptor.cpp +++ b/services/audio_policy/server/domain/device/src/audio_device_descriptor.cpp @@ -267,7 +267,7 @@ bool AudioDeviceDescriptor::IsAudioDeviceDescriptor() const return descriptorType_ == AUDIO_DEVICE_DESCRIPTOR; } -void AudioDeviceDescriptor::SetClientInfo(std::shared_ptr clientInfo) const +void AudioDeviceDescriptor::SetClientInfo(const ClientInfo &clientInfo) const { clientInfo_ = clientInfo; } @@ -275,22 +275,20 @@ void AudioDeviceDescriptor::SetClientInfo(std::shared_ptr clientInfo bool AudioDeviceDescriptor::Marshalling(Parcel &parcel) const { bool ret = MarshallingInner(parcel); - if (clientInfo_) { - clientInfo_ = nullptr; - } + clientInfo_ = std::nullopt; return ret; } bool AudioDeviceDescriptor::MarshallingInner(Parcel &parcel) const { if (clientInfo_ && !IsAudioDeviceDescriptor()) { - return MarshallingToDeviceInfo(parcel, clientInfo_->hasBTPermission_, - clientInfo_->hasSystemPermission_, clientInfo_->apiVersion_); + return MarshallingToDeviceInfo(parcel, clientInfo_.value().hasBTPermission_, + clientInfo_.value().hasSystemPermission_, clientInfo_.value().apiVersion_); } int32_t devType = deviceType_; if (IsAudioDeviceDescriptor()) { - devType = MapInternalToExternalDeviceType(clientInfo_ ? clientInfo_->apiVersion_ : 0); + devType = MapInternalToExternalDeviceType(clientInfo_ ? clientInfo_.value().apiVersion_ : 0); } return parcel.WriteInt32(devType) && @@ -481,6 +479,11 @@ bool AudioDeviceDescriptor::IsDistributedSpeaker() const return deviceType_ == DEVICE_TYPE_SPEAKER && networkId_ != "LocalDevice"; } +bool AudioDeviceDescriptor::IsRemote() const +{ + return networkId_ != "LocalDevice"; +} + void AudioDeviceDescriptor::Dump(std::string &dumpString) { AppendFormat(dumpString, " - device %d: role %s type %d (%s) name: %s\n", diff --git a/services/audio_policy/server/domain/device/src/audio_device_manager.cpp b/services/audio_policy/server/domain/device/src/audio_device_manager.cpp index 7014bdc8025b9ef8afe1fd1e66d810f53d95a54a..bc9d7555782f667133c15a07485882eed58bf505 100644 --- a/services/audio_policy/server/domain/device/src/audio_device_manager.cpp +++ b/services/audio_policy/server/domain/device/src/audio_device_manager.cpp @@ -1272,7 +1272,7 @@ DeviceUsage AudioDeviceManager::GetDeviceUsage(const AudioDeviceDescriptor &desc return usage; } -void AudioDeviceManager::OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName) +void AudioDeviceManager::OnReceiveUpdateDeviceNameEvent(const std::string macAddress, const std::string deviceName) { std::lock_guard currentActiveDevicesLock(currentActiveDevicesMutex_); for (auto device : connectedDevices_) { diff --git a/services/audio_policy/server/domain/device/src/audio_device_status.cpp b/services/audio_policy/server/domain/device/src/audio_device_status.cpp index 07eb40c5a2233ccf9e076b77815b007e662ac51e..c62e54ff6e0e4476c2a670e66af26c72b8856d34 100644 --- a/services/audio_policy/server/domain/device/src/audio_device_status.cpp +++ b/services/audio_policy/server/domain/device/src/audio_device_status.cpp @@ -740,9 +740,15 @@ void AudioDeviceStatus::OnDeviceConfigurationChanged(DeviceType deviceType, cons "macAddress:[%{public}s], activeBTDevice:[%{public}s]", deviceType, audioActiveDevice_.GetCurrentOutputDeviceType(), GetEncryptAddr(macAddress).c_str(), GetEncryptAddr(btDevice).c_str()); - // only for the active a2dp device. + + // Bt configuration changed cases: + // 1) To another stream info: Reload pipe by new stream info. + // 2) To another bt device: Reload pipe by new stream info. + // 3) To SBC/L2HC codec: Re-fetch pipes for all streams, may change from a2dp to a2dp offload. if ((deviceType == DEVICE_TYPE_BLUETOOTH_A2DP) && !macAddress.compare(btDevice)) { - int32_t activeSessionsSize = 0; + AudioCoreService::GetCoreService()->FetchOutputDeviceAndRoute("BtConfigurationChanged"); + AudioCoreService::GetCoreService()->FetchInputDeviceAndRoute("BtConfigurationChanged"); + uint32_t activeSessionsSize = 0; BluetoothOffloadState state = NO_A2DP_DEVICE; if (audioA2dpOffloadManager_) { activeSessionsSize = audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForAllStream(); @@ -1072,7 +1078,6 @@ int32_t AudioDeviceStatus::OnServiceConnected(AudioServiceIndex serviceIndex) if (OpenPortAndAddDeviceOnServiceConnected(moduleInfo)) { result = SUCCESS; } - audioOffloadStream_.SetOffloadAvailableFromXML(moduleInfo); } } @@ -1396,8 +1401,8 @@ void AudioDeviceStatus::RemoveDeviceFromGlobalOnly(std::shared_ptrFetchOutputDeviceAndRoute("RemoveDeviceFromGlobalOnly"); - AudioCoreService::GetCoreService()->FetchInputDeviceAndRoute("RemoveDeviceFromGlobalOnly"); + AudioCoreService::GetCoreService()->GetEventEntry()->FetchOutputDeviceAndRoute("RemoveDeviceFromGlobalOnly"); + AudioCoreService::GetCoreService()->GetEventEntry()->FetchInputDeviceAndRoute("RemoveDeviceFromGlobalOnly"); } void AudioDeviceStatus::AddDeviceBackToGlobalOnly(std::shared_ptr desc) @@ -1408,8 +1413,8 @@ void AudioDeviceStatus::AddDeviceBackToGlobalOnly(std::shared_ptrFetchOutputDeviceAndRoute("AddDeviceBackToGlobalOnly"); - AudioCoreService::GetCoreService()->FetchInputDeviceAndRoute("AddDeviceBackToGlobalOnly"); + AudioCoreService::GetCoreService()->GetEventEntry()->FetchOutputDeviceAndRoute("AddDeviceBackToGlobalOnly"); + AudioCoreService::GetCoreService()->GetEventEntry()->FetchInputDeviceAndRoute("AddDeviceBackToGlobalOnly"); } void AudioDeviceStatus::HandleOfflineDistributedDevice() diff --git a/services/audio_policy/server/domain/device/src/audio_recovery_device.cpp b/services/audio_policy/server/domain/device/src/audio_recovery_device.cpp index 762275eed6fb06b1532e05564d7192351748dba3..4d697ebc5478fc346dffa2df01a48c84007ee6d2 100644 --- a/services/audio_policy/server/domain/device/src/audio_recovery_device.cpp +++ b/services/audio_policy/server/domain/device/src/audio_recovery_device.cpp @@ -251,7 +251,7 @@ void AudioRecoveryDevice::HandleFetchDeviceChange(const AudioStreamDeviceChangeR currentOutputDevice, caller); if ((currentOutputDevice.deviceType_ != DEVICE_TYPE_BLUETOOTH_A2DP) || (currentOutputDevice.networkId_ != LOCAL_NETWORK_ID)) { - audioA2dpOffloadManager_->UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); + audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForA2dpDeviceOut(); } else { audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForAllStream(currentOutputDevice.deviceType_); } @@ -473,7 +473,7 @@ int32_t AudioRecoveryDevice::ExcludeOutputDevices(AudioDeviceUsage audioDevUsage currentInputDevice, currentOutputDevice, "ExcludeOutputDevices"); if ((currentOutputDevice.deviceType_ != DEVICE_TYPE_BLUETOOTH_A2DP) || (currentOutputDevice.networkId_ != LOCAL_NETWORK_ID)) { - audioA2dpOffloadManager_->UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); + audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForA2dpDeviceOut(); } else { audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForAllStream(currentOutputDevice.deviceType_); } @@ -500,7 +500,7 @@ int32_t AudioRecoveryDevice::UnexcludeOutputDevices(AudioDeviceUsage audioDevUsa currentInputDevice, currentOutputDevice, "UnexcludeOutputDevices"); if ((currentOutputDevice.deviceType_ != DEVICE_TYPE_BLUETOOTH_A2DP) || (currentOutputDevice.networkId_ != LOCAL_NETWORK_ID)) { - audioA2dpOffloadManager_->UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); + audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForA2dpDeviceOut(); } else { audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForAllStream(currentOutputDevice.deviceType_); } diff --git a/services/audio_policy/server/domain/device/src/sle/sle_audio_device_manager.cpp b/services/audio_policy/server/domain/device/src/sle/sle_audio_device_manager.cpp index 7b24892bba0fd17678381d51d5a8038843eb6170..330a14e1005db056fd9174a277a907e6ae93c94e 100644 --- a/services/audio_policy/server/domain/device/src/sle/sle_audio_device_manager.cpp +++ b/services/audio_policy/server/domain/device/src/sle/sle_audio_device_manager.cpp @@ -384,6 +384,9 @@ void SleAudioDeviceManager::ResetSleStreamTypeCount(const std::shared_ptrmacAddress_, streamType); } + auto ret = SetActiveSinkDevice(deviceDesc->macAddress_, SLE_AUDIO_STREAM_NONE); + CHECK_AND_RETURN_LOG(ret == SUCCESS, "set active device failed, ret: %{public}d", ret); + startedSleStreamType_.erase(it); } diff --git a/services/audio_policy/server/domain/device/test/BUILD.gn b/services/audio_policy/server/domain/device/test/BUILD.gn index d54e6076829d7840083940b7c1b32bb5af6131e1..1dce62afc8a2ace5c09f58bd747d4e381351503a 100644 --- a/services/audio_policy/server/domain/device/test/BUILD.gn +++ b/services/audio_policy/server/domain/device/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../../accessibility.gni") import("../../../../../../appgallery.gni") -import("../../../../../../av_session.gni") import("../../../../../../bluetooth_part.gni") import("../../../../../../config.gni") diff --git a/services/audio_policy/server/domain/effect/include/audio_collaborative_service.h b/services/audio_policy/server/domain/effect/include/audio_collaborative_service.h index 563f9ee77215b5dbf821e10123e4f882399ce5ef..ebe9a41a0f359f213345995dc011d14aa83b598b 100644 --- a/services/audio_policy/server/domain/effect/include/audio_collaborative_service.h +++ b/services/audio_policy/server/domain/effect/include/audio_collaborative_service.h @@ -22,6 +22,13 @@ #include "iaudio_policy_interface.h" namespace OHOS { namespace AudioStandard { + +enum CollaborativeState: uint32_t { + COLLABORATIVE_CLOSED = 0, + COLLABORATIVE_OPENED, + COLLABORATIVE_RESERVED, +}; + class AudioCollaborativeService { public: static AudioCollaborativeService& GetAudioCollaborativeService() @@ -46,13 +53,14 @@ private: ~AudioCollaborativeService(); // outputDeviceChange differentiate if updation is caused by output device change int32_t UpdateCollaborativeStateReal(); + void RecoverCollaborativeState(); + void WriteCollaborativeStateSysEvents(std::string macAddress_, CollaborativeState state); bool isCollaborativePlaybackSupported_ = false; // same with current device in map bool isCollaborativeStateEnabled_ = false; std::string curDeviceAddress_; std::mutex collaborativeServiceMutex_; - std::map addressToCollaborativeEnabledMap_; - std::map addressToCollaborativeMemoryMap_; + std::map addressToCollaborativeEnabledMap_; IAudioPolicyInterface& audioPolicyManager_; }; } // OHOS diff --git a/services/audio_policy/server/domain/effect/src/audio_collaborative_service.cpp b/services/audio_policy/server/domain/effect/src/audio_collaborative_service.cpp index 6193bee081c012e1757c684bfde02baedcb54b6e..c959dfa3a042434dd21520430752908a790ba7d8 100644 --- a/services/audio_policy/server/domain/effect/src/audio_collaborative_service.cpp +++ b/services/audio_policy/server/domain/effect/src/audio_collaborative_service.cpp @@ -17,6 +17,7 @@ #endif #include #include "audio_collaborative_service.h" +#include "media_monitor_manager.h" namespace OHOS { namespace AudioStandard { @@ -51,6 +52,8 @@ void AudioCollaborativeService::Init(const std::vector &effectChain isCollaborativePlaybackSupported_ = true; } } + RecoverCollaborativeState(); + UpdateCollaborativeStateReal(); } bool AudioCollaborativeService::IsCollaborativePlaybackSupported() @@ -68,19 +71,20 @@ void AudioCollaborativeService::UpdateCurrentDevice(const AudioDeviceDescriptor AUDIO_INFO_LOG("Update current device macAddress %{public}s for AudioCollaborativeSerivce", GetEncryptAddr(curDeviceAddress_).c_str()); } - // current device is not A2DP but already in map. May change from A2DP to SCO - // remember enable state for the address temporarily in memory map + // current device is not A2DP but already in map and opened. May change from A2DP to SCO + // collaborative closed when SCO but reserved, will recover to opened later if ((selectedAudioDevice.deviceType_ != DEVICE_TYPE_BLUETOOTH_A2DP) && - addressToCollaborativeEnabledMap_.find(curDeviceAddress_) != addressToCollaborativeEnabledMap_.end()) { - addressToCollaborativeMemoryMap_[curDeviceAddress_] = addressToCollaborativeEnabledMap_[curDeviceAddress_]; - addressToCollaborativeEnabledMap_.erase(curDeviceAddress_); + addressToCollaborativeEnabledMap_.find(curDeviceAddress_) != addressToCollaborativeEnabledMap_.end() && + addressToCollaborativeEnabledMap_[curDeviceAddress_] == COLLABORATIVE_OPENED) { + addressToCollaborativeEnabledMap_[curDeviceAddress_] = COLLABORATIVE_RESERVED; + WriteCollaborativeStateSysEvents(curDeviceAddress_, addressToCollaborativeEnabledMap_[curDeviceAddress_]); } - // current device is A2DP but not in map, may be remembered in memory map, put it back to enable map + // current device is A2DP and is reserved state, which comes back from other type like SCO, should be opened if ((selectedAudioDevice.deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) && - addressToCollaborativeEnabledMap_.find(curDeviceAddress_) == addressToCollaborativeEnabledMap_.end() && - addressToCollaborativeMemoryMap_.find(curDeviceAddress_) != addressToCollaborativeMemoryMap_.end()) { - addressToCollaborativeEnabledMap_[curDeviceAddress_] = addressToCollaborativeMemoryMap_[curDeviceAddress_]; - addressToCollaborativeMemoryMap_.erase(curDeviceAddress_); + addressToCollaborativeEnabledMap_.find(curDeviceAddress_) != addressToCollaborativeEnabledMap_.end() && + addressToCollaborativeEnabledMap_[curDeviceAddress_] == COLLABORATIVE_RESERVED) { + addressToCollaborativeEnabledMap_[curDeviceAddress_] = COLLABORATIVE_OPENED; + WriteCollaborativeStateSysEvents(curDeviceAddress_, addressToCollaborativeEnabledMap_[curDeviceAddress_]); } UpdateCollaborativeStateReal(); } @@ -92,7 +96,8 @@ int32_t AudioCollaborativeService::SetCollaborativePlaybackEnabledForDevice( std::lock_guard lock(collaborativeServiceMutex_); std::string deviceAddress = selectedAudioDevice->macAddress_; AUDIO_INFO_LOG("Device Collaborative Enabled should be set to: %{public}d", enabled); - addressToCollaborativeEnabledMap_[deviceAddress] = enabled; + addressToCollaborativeEnabledMap_[deviceAddress] = enabled ? COLLABORATIVE_OPENED : COLLABORATIVE_CLOSED; + WriteCollaborativeStateSysEvents(deviceAddress, addressToCollaborativeEnabledMap_[deviceAddress]); return UpdateCollaborativeStateReal(); } @@ -106,7 +111,7 @@ bool AudioCollaborativeService::IsCollaborativePlaybackEnabledForDevice( AUDIO_INFO_LOG("selected device address %{public}s is in addressToCollaborativeEnabledMap_, state %{public}d", GetEncryptAddr(selectedAudioDevice->macAddress_).c_str(), addressToCollaborativeEnabledMap_[selectedAudioDevice->macAddress_]); - return addressToCollaborativeEnabledMap_[selectedAudioDevice->macAddress_]; + return addressToCollaborativeEnabledMap_[selectedAudioDevice->macAddress_] == COLLABORATIVE_OPENED; } AUDIO_INFO_LOG("address %{public}s is not in map", selectedAudioDevice->macAddress_.c_str()); return false; @@ -127,8 +132,9 @@ int32_t AudioCollaborativeService::UpdateCollaborativeStateReal() } return SUCCESS; } - if (addressToCollaborativeEnabledMap_[curDeviceAddress_] != isCollaborativeStateEnabled_) { - isCollaborativeStateEnabled_ = addressToCollaborativeEnabledMap_[curDeviceAddress_]; + bool isCurrentCollaborativeEnabled = (addressToCollaborativeEnabledMap_[curDeviceAddress_] == COLLABORATIVE_OPENED); + if (isCollaborativeStateEnabled_ != isCurrentCollaborativeEnabled) { + isCollaborativeStateEnabled_ = isCurrentCollaborativeEnabled; AUDIO_INFO_LOG("current collaborative enabled state changed to %{public}d for Mac address %{public}s", isCollaborativeStateEnabled_, GetEncryptAddr(curDeviceAddress_).c_str()); return audioPolicyManager_.UpdateCollaborativeState(isCollaborativeStateEnabled_); // send to HpaeManager @@ -144,6 +150,25 @@ bool AudioCollaborativeService::GetRealCollaborativeState() return isCollaborativeStateEnabled_; } +void AudioCollaborativeService::WriteCollaborativeStateSysEvents(std::string macAddress_, CollaborativeState state) +{ + std::shared_ptr bean = std::make_shared( + Media::MediaMonitor::AUDIO, Media::MediaMonitor::SET_DEVICE_COLLABORATIVE_STATE, + Media::MediaMonitor::BEHAVIOR_EVENT); + bean->Add("ADDRESS", macAddress_); + bean->Add("COLLABORATIVE_STATE", static_cast(state)); + Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean); +} + +void AudioCollaborativeService::RecoverCollaborativeState() +{ + std::map storedCollaborativeState; + Media::MediaMonitor::MediaMonitorManager::GetInstance().GetCollaborativeDeviceState(storedCollaborativeState); + for (auto p: storedCollaborativeState) { + addressToCollaborativeEnabledMap_[p.first] = static_cast(p.second); + } +} + AudioCollaborativeService::~AudioCollaborativeService() { AUDIO_ERR_LOG("~AudioCollaborativeService"); diff --git a/services/audio_policy/server/domain/effect/test/BUILD.gn b/services/audio_policy/server/domain/effect/test/BUILD.gn index 6832cf822c5582f8fe7f6ce2aace20fb1a663461..94c8e4a04ed127092ee9f5d3c2e76e640d77d08f 100644 --- a/services/audio_policy/server/domain/effect/test/BUILD.gn +++ b/services/audio_policy/server/domain/effect/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../../accessibility.gni") import("../../../../../../appgallery.gni") -import("../../../../../../av_session.gni") import("../../../../../../bluetooth_part.gni") import("../../../../../../config.gni") diff --git a/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h b/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h index 89daf238e852ee4b156c5995ae8b08ef5661fdca..66bab7e59a10559b81c9399f346082d45b25d295 100644 --- a/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h +++ b/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h @@ -121,6 +121,11 @@ public: std::set GetStreamIdsForAudioSessionByDeviceType(const int32_t zoneId, DeviceType deviceType); std::vector GetAudioSessionUidList(int32_t zoneId); StreamUsage GetAudioSessionStreamUsage(int32_t callerPid); + + bool ShouldAudioServerProcessInruptEvent(const InterruptEventInternal &interruptEvent, + const AudioInterrupt &audioInterrupt); + void SendInterruptEventToAudioServer(const InterruptEventInternal &interruptEvent, + const AudioInterrupt &audioInterrupt); void ProcessRemoteInterrupt(std::set streamIds, InterruptEventInternal interruptEvent); int32_t SetQueryBundleNameListCallback(const sptr &object); @@ -135,7 +140,6 @@ private: static constexpr int32_t ZONEID_INVALID = -1; static constexpr float DUCK_FACTOR = 0.2f; static constexpr int32_t DEFAULT_APP_PID = -1; - static constexpr int64_t OFFLOAD_NO_SESSION_ID = -1; static constexpr int32_t STREAM_DEFAULT_PRIORITY = 100; using InterruptIterator = std::list>::iterator>; @@ -330,6 +334,9 @@ private: std::list>::iterator &activeInterrupt); void ReportRecordGetFocusFail(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, int32_t reason); + void HandleVoiceCallAndTranscriptionFocus( + std::map, AudioFocusEntry> &focusMap, + const AudioInterrupt ¤tInterrupt, const AudioInterrupt &newInterrupt); // interrupt members sptr policyServer_; diff --git a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp index d7eac417205d72a70a75c72bf4bb2cc28925c6e7..5b8696e2c37726680c006a1b73424babb75338b8 100644 --- a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp +++ b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp @@ -33,6 +33,7 @@ #include "istandard_audio_service.h" #include "session_manager_lite.h" #include "audio_zone_service.h" +#include "audio_server_proxy.h" #include "standalone_mode_manager.h" namespace OHOS { @@ -921,6 +922,10 @@ int32_t AudioInterruptService::ActivateAudioInterruptInternal(const int32_t zone incomingStreamId, currAudioInterrupt.pid, streamType, zoneId, currAudioInterrupt.streamUsage, (currAudioInterrupt.audioFocusType).sourceType); +#ifdef FEATURE_MULTIMODALINPUT_INPUT + CHECK_AND_RETURN_RET_LOG(policyServer_ != nullptr, ERR_FOCUS_DENIED, "policyServer nullptr"); + policyServer_->ReloadLoudVolumeMode(streamType); +#endif if (AudioInterruptIsActiveInFocusList(zoneId, incomingStreamId) && !isUpdatedAudioStrategy) { AUDIO_INFO_LOG("Stream is active in focus list, no need to active audio interrupt."); return SUCCESS; @@ -952,15 +957,18 @@ int32_t AudioInterruptService::ActivateAudioInterruptInternal(const int32_t zone void AudioInterruptService::PrintLogsOfFocusStrategyBaseMusic(const AudioInterrupt &audioInterrupt) { // The log printed by this function is critical, so please do not modify it. + std::string bundleName = (AudioBundleManager::GetBundleInfoFromUid(audioInterrupt.uid)).name; + AudioFocusType audioFocusType; audioFocusType.streamType = AudioStreamType::STREAM_MUSIC; - std::pair focusPair = - std::make_pair(audioFocusType, audioInterrupt.audioFocusType); + std::pair focusPair = std::make_pair(audioFocusType, audioInterrupt.audioFocusType); CHECK_AND_RETURN_LOG(focusCfgMap_.find(focusPair) != focusCfgMap_.end(), "no focus cfg"); AudioFocusEntry focusEntry = focusCfgMap_[focusPair]; if (focusEntry.actionOn != CURRENT) { AUDIO_WARNING_LOG("The audio focus strategy based on music: forceType: %{public}d, hintType: %{public}d, " \ - "actionOn: %{public}d", focusEntry.forceType, focusEntry.hintType, focusEntry.actionOn); + "actionOn: %{public}d. Caller info: pid [%{public}d], uid [%{public}d], bundleName [%{public}s].", + focusEntry.forceType, focusEntry.hintType, focusEntry.actionOn, + audioInterrupt.pid, audioInterrupt.uid, bundleName.c_str()); return; } // Update focus strategy by audio session. @@ -976,23 +984,18 @@ void AudioInterruptService::PrintLogsOfFocusStrategyBaseMusic(const AudioInterru switch (concurrencyMode) { case AudioConcurrencyMode::MIX_WITH_OTHERS: case AudioConcurrencyMode::SILENT: - if (focusEntry.hintType == INTERRUPT_HINT_DUCK || - focusEntry.hintType == INTERRUPT_HINT_PAUSE || + if (focusEntry.hintType == INTERRUPT_HINT_DUCK || focusEntry.hintType == INTERRUPT_HINT_PAUSE || focusEntry.hintType == INTERRUPT_HINT_STOP) { focusEntry.hintType = INTERRUPT_HINT_NONE; } break; - case AudioConcurrencyMode::DUCK_OTHERS: - if (focusEntry.hintType == INTERRUPT_HINT_DUCK || - focusEntry.hintType == INTERRUPT_HINT_PAUSE || - focusEntry.hintType == INTERRUPT_HINT_STOP) { + if (focusEntry.hintType == INTERRUPT_HINT_PAUSE || focusEntry.hintType == INTERRUPT_HINT_STOP) { focusEntry.hintType = INTERRUPT_HINT_DUCK; } break; case AudioConcurrencyMode::PAUSE_OTHERS: - if (focusEntry.hintType == INTERRUPT_HINT_PAUSE || - focusEntry.hintType == INTERRUPT_HINT_STOP) { + if (focusEntry.hintType == INTERRUPT_HINT_STOP) { focusEntry.hintType = INTERRUPT_HINT_PAUSE; } break; @@ -1000,7 +1003,9 @@ void AudioInterruptService::PrintLogsOfFocusStrategyBaseMusic(const AudioInterru break; } AUDIO_WARNING_LOG("The audio focus strategy based on music: forceType: %{public}d, hintType: %{public}d, " \ - "actionOn: %{public}d", focusEntry.forceType, focusEntry.hintType, focusEntry.actionOn); + "actionOn: %{public}d. Caller info: pid [%{public}d], uid [%{public}d], bundleName [%{public}s].", + focusEntry.forceType, focusEntry.hintType, focusEntry.actionOn, + audioInterrupt.pid, audioInterrupt.uid, bundleName.c_str()); return; } @@ -1558,6 +1563,49 @@ void AudioInterruptService::ProcessRemoteInterrupt(std::set streamIds, targetZoneIt->second->audioFocusInfoList = tmpFocusInfoList; } +void AudioInterruptService::HandleVoiceCallAndTranscriptionFocus( + std::map, AudioFocusEntry> &focusMap, + const AudioInterrupt ¤tInterrupt, const AudioInterrupt &newInterrupt) +{ + bool isSourceVoiceCall = (currentInterrupt.audioFocusType.streamType == STREAM_VOICE_CALL || + currentInterrupt.audioFocusType.sourceType == SOURCE_TYPE_VOICE_CALL) && + (newInterrupt.audioFocusType.sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION); + bool isSourceVoiceTranscripTion = (currentInterrupt.audioFocusType.sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION) && + (newInterrupt.audioFocusType.sourceType == SOURCE_TYPE_VOICE_CALL || + newInterrupt.audioFocusType.streamType == STREAM_VOICE_CALL); + + uint32_t mutesessionId = 0; + if (isSourceVoiceCall) { + mutesessionId = newInterrupt.streamId; + } + if (isSourceVoiceTranscripTion) { + mutesessionId = currentInterrupt.streamId; + } + AUDIO_INFO_LOG("current streamtype: %{public}d, sourcetype: %{public}d, newInterrupt streamtype: %{public}d, " + "sourcetype: %{public}d, mutesessionId:%{public}d", + currentInterrupt.audioFocusType.streamType, currentInterrupt.audioFocusType.sourceType, + newInterrupt.audioFocusType.streamType, newInterrupt.audioFocusType.sourceType, mutesessionId); + if (isSourceVoiceCall || isSourceVoiceTranscripTion) { + auto key = std::make_pair(currentInterrupt.audioFocusType, newInterrupt.audioFocusType); + auto it = focusMap.find(key); + if (it == focusMap.end()) { + return; + } + + CHECK_AND_RETURN_LOG(policyServer_ != nullptr, "policyServer nullptr"); + if (policyServer_->VerifyPermission(RECORD_VOICE_CALL_PERMISSION)) { + AUDIO_INFO_LOG("VerifyPermission mutesessionId:%{public}d", mutesessionId); + it->second.forceType = INTERRUPT_FORCE; + it->second.hintType = INTERRUPT_HINT_NONE; + it->second.actionOn = INCOMING; + it->second.isReject = false; + policyServer_->SetVoiceMuteState(mutesessionId, false); + } else { + policyServer_->SetVoiceMuteState(mutesessionId, true); + } + } +} + void AudioInterruptService::ProcessActiveInterrupt(const int32_t zoneId, const AudioInterrupt &incomingInterrupt) { // Use local variable to record target focus info list, can be optimized @@ -1573,6 +1621,7 @@ void AudioInterruptService::ProcessActiveInterrupt(const int32_t zoneId, const A std::list removeFocusInfoPidList = {}; InterruptDfxBuilder dfxBuilder; for (auto iterActive = tmpFocusInfoList.begin(); iterActive != tmpFocusInfoList.end();) { + HandleVoiceCallAndTranscriptionFocus(focusCfgMap_, iterActive->first, incomingInterrupt); AudioFocusEntry focusEntry = focusCfgMap_[std::make_pair((iterActive->first).audioFocusType, incomingInterrupt.audioFocusType)]; UpdateAudioFocusStrategy(iterActive->first, incomingInterrupt, focusEntry); @@ -2457,6 +2506,43 @@ void AudioInterruptService::SendInterruptEvent(AudioFocuState oldState, AudioFoc iterActive->second = newState; } +bool AudioInterruptService::ShouldAudioServerProcessInruptEvent(const InterruptEventInternal &interruptEvent, + const AudioInterrupt &audioInterrupt) +{ + CHECK_AND_RETURN_RET_LOG(!audioInterrupt.audioFocusType.isPlay, false, + "audioServer need not process playback interruptEvent"); + +#ifdef FEATURE_APPGALLERY + auto it = interruptClients_.find(audioInterrupt.streamId); + if (it != interruptClients_.end() && it->second != nullptr) { + uint32_t uid = interruptClients_[audioInterrupt.streamId]->GetCallingUid(); + ClientType clientType = ClientTypeManager::GetInstance()->GetClientTypeByUid(uid); + CHECK_AND_RETURN_RET_LOG(clientType != CLIENT_TYPE_GAME, false, "clientType is Game"); + } +#endif + auto hintType = interruptEvent.hintType; + return hintType == INTERRUPT_HINT_PAUSE || hintType == INTERRUPT_HINT_RESUME; +} + +void AudioInterruptService::SendInterruptEventToAudioServer( + const InterruptEventInternal &interruptEvent, const AudioInterrupt &audioInterrupt) +{ + CHECK_AND_RETURN_LOG(ShouldAudioServerProcessInruptEvent(interruptEvent, audioInterrupt), + "need not send audioInterrupt to audioServer"); + if (audioInterrupt.isAudioSessionInterrupt) { + AUDIO_INFO_LOG("is audioSession interrupt"); + CHECK_AND_RETURN_LOG(sessionService_ != nullptr, "sessionService_ is nullptr"); + const auto &audioInterrupts = sessionService_->GetStreams(audioInterrupt.pid); + for (auto &it : audioInterrupts) { + AudioServerProxy::GetInstance().SendInterruptEventToAudioServerProxy( + interruptEvent, it.streamId); + } + } else { + AudioServerProxy::GetInstance().SendInterruptEventToAudioServerProxy( + interruptEvent, audioInterrupt.streamId); + } +} + void AudioInterruptService::SendInterruptEventCallback(const InterruptEventInternal &interruptEvent, const uint32_t &streamId, const AudioInterrupt &audioInterrupt) { @@ -2478,7 +2564,7 @@ void AudioInterruptService::SendInterruptEventCallback(const InterruptEventInter AUDIO_ERR_LOG("AudioPolicyServerHandler is nullptr"); return; } - + SendInterruptEventToAudioServer(interruptEvent, audioInterrupt); if (audioInterrupt.isAudioSessionInterrupt) { SendAudioSessionInterruptEventCallback(interruptEvent, audioInterrupt); } else { diff --git a/services/audio_policy/server/domain/pipe/include/audio_a2dp_offload_manager.h b/services/audio_policy/server/domain/pipe/include/audio_a2dp_offload_manager.h index b534480de9924ef86d08efcb3704a1dea8742310..9262fcfed472a7f132d9cf15681e2a78aac819d3 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_a2dp_offload_manager.h +++ b/services/audio_policy/server/domain/pipe/include/audio_a2dp_offload_manager.h @@ -1,4 +1,3 @@ - /* * Copyright (c) 2021-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,34 +16,22 @@ #ifndef ST_AUDIO_A2DP_OFFLOAD_MANAGER_H #define ST_AUDIO_A2DP_OFFLOAD_MANAGER_H -#include -#include #include #include -#include +#include #include -#include "singleton.h" -#include "audio_group_handle.h" -#include "audio_manager_base.h" -#include "audio_module_info.h" + #include "audio_errors.h" -#include "audio_router_center.h" -#include "audio_policy_manager_factory.h" -#include "audio_stream_collector.h" +#include "audio_policy_log.h" #ifdef BLUETOOTH_ENABLE -#include "audio_server_death_recipient.h" #include "audio_bluetooth_manager.h" #include "bluetooth_device_manager.h" #endif -#include "audio_device_common.h" -#include "audio_volume_manager.h" -#include "audio_a2dp_offload_flag.h" -#include "audio_iohandle_map.h" -#include "audio_policy_config_manager.h" #include "audio_active_device.h" -#include "audio_offload_stream.h" +#include "audio_stream_collector.h" +#include "audio_a2dp_offload_flag.h" namespace OHOS { namespace AudioStandard { @@ -52,65 +39,65 @@ namespace AudioStandard { class AudioA2dpOffloadManager final : public Bluetooth::AudioA2dpPlayingStateChangedListener, public std::enable_shared_from_this { public: - AudioA2dpOffloadManager() : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), - streamCollector_(AudioStreamCollector::GetAudioStreamCollector()), + AudioA2dpOffloadManager() + : streamCollector_(AudioStreamCollector::GetAudioStreamCollector()), audioA2dpOffloadFlag_(AudioA2dpOffloadFlag::GetInstance()), - audioRouterCenter_(AudioRouterCenter::GetAudioRouterCenter()), - audioIOHandleMap_(AudioIOHandleMap::GetInstance()), - audioActiveDevice_(AudioActiveDevice::GetInstance()), - audioConfigManager_(AudioPolicyConfigManager::GetInstance()), - audioVolumeManager_(AudioVolumeManager::GetInstance()), - audioOffloadStream_(AudioOffloadStream::GetInstance()), - audioDeviceCommon_(AudioDeviceCommon::GetInstance()) + audioActiveDevice_(AudioActiveDevice::GetInstance()) {} void Init() {Bluetooth::AudioA2dpManager::RegisterA2dpPlayingStateChangedListener(shared_from_this());}; - void ConnectA2dpOffload(const std::string &deviceAddress, const std::vector &sessionIds); - void OnA2dpPlayingStateChanged(const std::string &deviceAddress, int32_t playingState) override; - void WaitForConnectionCompleted(); + void OnA2dpPlayingStateChanged(const std::string &deviceAddress, int32_t playingState) override; + bool IsA2dpOffloadConnecting(int32_t sessionId); bool IsA2dpOffloadConnected(); void SetA2dpOffloadFlag(BluetoothOffloadState state); BluetoothOffloadState GetA2dpOffloadFlag(); - int32_t OffloadStartPlaying(const std::vector &sessionIds); - int32_t OffloadStopPlaying(const std::vector &sessionIds); - void UpdateA2dpOffloadFlagForAllStream(std::unordered_map &sessionIDToSpatializationEnableMap, + void UpdateA2dpOffloadFlagForStartStream(int32_t startSessionId); + uint32_t UpdateA2dpOffloadFlagForAllStream(DeviceType deviceType = DEVICE_TYPE_NONE); + void UpdateA2dpOffloadFlagForSpatializationChanged( + std::unordered_map &sessionIDToSpatializationEnabledMap, DeviceType deviceType = DEVICE_TYPE_NONE); - int32_t UpdateA2dpOffloadFlagForAllStream(DeviceType deviceType = DEVICE_TYPE_NONE); - void UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); + void UpdateA2dpOffloadFlagForA2dpDeviceOut(); private: + uint32_t UpdateA2dpOffloadFlagCommon( + int32_t startSessionId, DeviceType deviceType, bool getSpatialFromService, + std::unordered_map &sessionIDToSpatializationEnabledMap); #ifdef BLUETOOTH_ENABLE - void UpdateA2dpOffloadFlag(const std::vector &allActiveSessions, - DeviceType deviceType = DEVICE_TYPE_NONE); + void UpdateA2dpOffloadFlagInternal(const std::vector &allActiveSessions, + std::vector &allRunningSessions, DeviceType deviceType = DEVICE_TYPE_NONE); #endif + + int32_t HandleA2dpDeviceInOffload(BluetoothOffloadState a2dpOffloadFlag, + std::vector &allRunningSessions); + int32_t HandleA2dpDeviceOutOffload(BluetoothOffloadState a2dpOffloadFlag, + std::vector &allRunningSessions); + int32_t OffloadStartPlaying(const std::vector &sessionIds); + int32_t OffloadStopPlaying(const std::vector &sessionIds); void GetA2dpOffloadCodecAndSendToDsp(); - int32_t HandleA2dpDeviceInOffload(BluetoothOffloadState a2dpOffloadFlag); - int32_t HandleA2dpDeviceOutOffload(BluetoothOffloadState a2dpOffloadFlag); - int32_t HandleActiveDevice(AudioDeviceDescriptor deviceDescriptor); - void FetchStreamForA2dpOffload(const bool &requireReset); - void GetAllRunningStreamSession(std::vector &allSessions, bool doStop = false); - std::string GetVolumeGroupType(DeviceType deviceType); + + // For spatialization and audio data sync + void ConnectA2dpOffload(const std::string &deviceAddress, const std::vector &sessionIds); + void WaitForConnectionCompleted(); + + // Tool funcs + bool GetSpatialAudio(bool getSpatialFromService, + int32_t sessionId, StreamUsage usage, + std::unordered_map &sessionIDToSpatializationEnabledMap); private: std::vector connectionTriggerSessionIds_; std::string a2dpOffloadDeviceAddress_ = ""; std::mutex connectionMutex_; std::condition_variable connectionCV_; + std::mutex switchA2dpOffloadMutex_; - IAudioPolicyInterface& audioPolicyManager_; - AudioStreamCollector& streamCollector_; - AudioA2dpOffloadFlag& audioA2dpOffloadFlag_; - AudioRouterCenter& audioRouterCenter_; - AudioIOHandleMap& audioIOHandleMap_; - AudioActiveDevice& audioActiveDevice_; - AudioPolicyConfigManager& audioConfigManager_; - AudioVolumeManager& audioVolumeManager_; - AudioOffloadStream& audioOffloadStream_; - AudioDeviceCommon& audioDeviceCommon_; + AudioStreamCollector &streamCollector_; + AudioA2dpOffloadFlag &audioA2dpOffloadFlag_; + AudioActiveDevice &audioActiveDevice_; }; -} -} -#endif \ No newline at end of file +} // namespace AudioStandard +} // namespace OHOS +#endif diff --git a/services/audio_policy/server/domain/pipe/include/audio_capturer_session.h b/services/audio_policy/server/domain/pipe/include/audio_capturer_session.h index f37611c9b629a36dbe60ac58880315eecd60e4df..d709b0d0ad21cc9a60799f47e9447b1261a9c3f0 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_capturer_session.h +++ b/services/audio_policy/server/domain/pipe/include/audio_capturer_session.h @@ -99,10 +99,19 @@ private: void SetInputDeviceTypeForReload(const AudioDeviceDescriptor &inputDevice); const AudioDeviceDescriptor& GetInputDeviceTypeForReload(); bool IsVoipDeviceChanged(const AudioDeviceDescriptor &inputDevcie, const AudioDeviceDescriptor &outputDevice); - bool FindRunningNormalSession(uint32_t sessionId, AudioCapturerChangeInfo &runingSessionInfo); + bool FindRunningNormalSession(uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo); std::string GetEnhancePropByName(const AudioEnhancePropertyArray &propertyArray, const std::string &propName); std::string GetEnhancePropByNameV3(const AudioEffectPropertyArrayV3 &oldPropertyArray, const std::string &propName); + bool IsInvalidPipeRole(const std::shared_ptr &pipe); + bool HandleIndependentInputpipe(const std::vector> &pipeList, + uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo, bool &hasSession); + bool HandleNormalInputPipes(const std::vector> &pipeList, + uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo, bool &hasSession); + bool IsStreamValid(const std::shared_ptr &stream); + bool CompareIndependentxmlPriority(const std::shared_ptr &pipe, + uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo, bool &hasSession); + bool IsRemainingSourceIndependent(); private: IAudioPolicyInterface& audioPolicyManager_; AudioRouterCenter& audioRouterCenter_; diff --git a/services/audio_policy/server/domain/pipe/include/audio_concurrency_service.h b/services/audio_policy/server/domain/pipe/include/audio_concurrency_service.h index 4c25d81fb54556ac592baa1c5d071c247d8f6742..b246d3f9220a5c15793cdeebae56586e4fdf45aa 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_concurrency_service.h +++ b/services/audio_policy/server/domain/pipe/include/audio_concurrency_service.h @@ -34,8 +34,10 @@ public: { AUDIO_ERR_LOG("dtor"); } + void Init(); - std::map, ConcurrencyAction>& GetConcurrencyMap(); + + ConcurrencyAction GetConcurrencyAction(const AudioPipeType existingPipe, const AudioPipeType commingPipe); private: std::map, ConcurrencyAction> concurrencyCfgMap_ = {}; diff --git a/services/audio_policy/server/domain/pipe/include/audio_definition_adapter_info.h b/services/audio_policy/server/domain/pipe/include/audio_definition_adapter_info.h index 10af15f06f3ad5ba85e1f4ab75c4b9ec5d48f9a6..ee199dd1e98b6e693eddafd60dcc43eee0f3c205 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_definition_adapter_info.h +++ b/services/audio_policy/server/domain/pipe/include/audio_definition_adapter_info.h @@ -143,6 +143,7 @@ public: AudioPreloadType preloadAttr_ = PRELOAD_TYPE_UNKNOWN; uint32_t supportFlags_ = AUDIO_FLAG_NONE; + uint32_t suspendIdleTimeout_ = DEFAULT_SUSPEND_TIME_IN_MS; int32_t audioUsage_ = AUDIO_USAGE_NORMAL; bool supportEncodingEac3_ = false; @@ -244,6 +245,35 @@ private: std::string version_ = STR_INITED; }; +struct AudioSourceStrategyType { + AudioSourceStrategyType() = default; + std::string hdiSource = "AUDIO_INPUT_MIC_TYPE"; + std::string adapterName = "primary"; + std::string pipeName = "primary_input"; + AudioFlag audioFlag = AUDIO_INPUT_FLAG_NORMAL; + uint32_t priority = 0; + + AudioSourceStrategyType(const std::string &hdiSource, const std::string &adapterName, const std::string &pipeName, + const AudioFlag &audioFlag, const uint32_t priority) + : hdiSource(hdiSource), adapterName(adapterName), pipeName(pipeName), audioFlag(audioFlag), priority(priority) + {} +}; + +class AudioSourceStrategyData { +public: + static AudioSourceStrategyData& GetInstance(); + std::shared_ptr> GetSourceStrategyMap() const; + void SetSourceStrategyMap(std::shared_ptr> newMap); + uint32_t MappingAudioFlag(const std::string& key) const; +private: + AudioSourceStrategyData() = default; + AudioSourceStrategyData(const AudioSourceStrategyData&) = delete; + AudioSourceStrategyData& operator=(const AudioSourceStrategyData&) = delete; + std::shared_ptr> sourceStrategyMap_ = + std::make_shared>(); + mutable std::mutex mutex_; +}; + } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/domain/pipe/include/audio_offload_stream.h b/services/audio_policy/server/domain/pipe/include/audio_offload_stream.h index 1253f52dec6f4a83ba196259467660697f845ec1..dd57d057097a1243a9c6b8feb8f014d107ba8305 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_offload_stream.h +++ b/services/audio_policy/server/domain/pipe/include/audio_offload_stream.h @@ -15,95 +15,75 @@ #ifndef ST_AUDIO_OFFLOAD_STREAM_H #define ST_AUDIO_OFFLOAD_STREAM_H -#include -#include #include -#include -#include +#include #include -#include "singleton.h" -#include "audio_group_handle.h" + #include "power_mgr_client.h" -#include "audio_manager_base.h" -#include "audio_module_info.h" -#include "audio_volume_config.h" -#include "audio_system_manager.h" -#include "audio_router_center.h" -#include "audio_errors.h" -#include "audio_policy_manager_factory.h" -#include "audio_stream_collector.h" -#include "ipc_skeleton.h" -#include "audio_router_map.h" -#include "audio_iohandle_map.h" -#include "audio_active_device.h" +#include "audio_info.h" +#include "audio_policy_manager_factory.h" #include "audio_stream_collector.h" namespace OHOS { namespace AudioStandard { +enum OffloadAdapter : uint32_t { + OFFLOAD_IN_PRIMARY = 0, + OFFLOAD_IN_REMOTE, + OFFLOAD_IN_ADAPTER_SIZE +}; + +enum OffloadAction : uint32_t { + OFFLOAD_NEW = 0, + OFFLOAD_MOVE_IN, + OFFLOAD_MOVE_OUT +}; + +constexpr uint32_t NO_OFFLOAD_STREAM_SESSIONID = 0; + class AudioOffloadStream { public: - static AudioOffloadStream& GetInstance() + static AudioOffloadStream &GetInstance() { static AudioOffloadStream instance; return instance; } - void OffloadStreamSetCheck(uint32_t sessionId); - void OffloadStreamReleaseCheck(uint32_t sessionId); + + uint32_t GetOffloadSessionId(OffloadAdapter offloadAdapter); + void SetOffloadStatus(OffloadAdapter offloadAdapter, uint32_t sessionId); + void UnsetOffloadStatus(uint32_t sessionId); void HandlePowerStateChanged(PowerMgr::PowerState state); - void ResetOffloadMode(int32_t sessionId); - int32_t MoveToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType); - void RemoteOffloadStreamRelease(uint32_t sessionId); - bool CheckStreamMultichannelMode(const int64_t activateSessionId); - int32_t MoveToOutputDevice(uint32_t sessionId, std::string portName); + void UpdateOffloadStatusFromUpdateTracker(uint32_t sessionId, RendererState state); + void Dump(std::string &dumpString); + + // not offload related std::vector FilterSinkInputs(int32_t sessionId, std::vector sinkInputs); - void SetOffloadAvailableFromXML(AudioModuleInfo &moduleInfo); - int32_t DynamicUnloadOffloadModule(); - int32_t UnloadMchModule(); - int32_t LoadMchModule(); - bool GetOffloadAvailableFromXml() const; - void ResetOffloadModeOnSpatializationChanged(std::vector &allSessions); - void SetOffloadStatus(uint32_t sessionId); - void ResetOffloadStatus(uint32_t sessionId); + private: - AudioOffloadStream() : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), - audioRouterCenter_(AudioRouterCenter::GetAudioRouterCenter()), - streamCollector_(AudioStreamCollector::GetAudioStreamCollector()), - audioIOHandleMap_(AudioIOHandleMap::GetInstance()), - audioRouteMap_(AudioRouteMap::GetInstance()), - audioActiveDevice_(AudioActiveDevice::GetInstance()) {} + AudioOffloadStream() + : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), + streamCollector_(AudioStreamCollector::GetAudioStreamCollector()) + { + for (uint32_t i = 0; i < OFFLOAD_IN_ADAPTER_SIZE; ++i) { + offloadSessionIdMap_[static_cast(i)] = NO_OFFLOAD_STREAM_SESSIONID; + } + } ~AudioOffloadStream() {} - bool CheckStreamOffloadMode(int64_t activateSessionId, AudioStreamType streamType); - bool CheckSpatializationAndEffectState(); - void SetOffloadMode(); - int32_t MoveToNewPipeInner(const uint32_t sessionId, const AudioPipeType pipeType); - int32_t SwitchToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType); - int32_t LoadOffloadModule(); - int32_t UnloadOffloadModule(); - AudioModuleInfo ConstructMchAudioModuleInfo(DeviceType deviceType); - AudioModuleInfo ConstructOffloadAudioModuleInfo(DeviceType deviceType); + + void SetOffloadStatusInternal(uint32_t sessionId); + void UnsetOffloadStatusInternal(uint32_t sessionId); + private: - std::optional offloadSessionID_; - PowerMgr::PowerState currentPowerState_ = PowerMgr::PowerState::AWAKE; + IAudioPolicyInterface &audioPolicyManager_; + AudioStreamCollector &streamCollector_; + std::mutex offloadMutex_; - bool currentOffloadSessionIsBackground_ = false; - bool isOffloadAvailable_ = false; - - std::mutex offloadCloseMutex_; - std::mutex offloadOpenMutex_; - std::atomic isOffloadOpened_ = false; - std::condition_variable offloadCloseCondition_; - - IAudioPolicyInterface& audioPolicyManager_; - AudioRouterCenter& audioRouterCenter_; - AudioStreamCollector& streamCollector_; - AudioIOHandleMap& audioIOHandleMap_; - AudioRouteMap& audioRouteMap_; - AudioActiveDevice& audioActiveDevice_; + std::map offloadSessionIdMap_ ; + PowerMgr::PowerState currentPowerState_ = PowerMgr::PowerState::AWAKE; }; -} -} +} // namespace AudioStandard +} // namespace OHOS #endif \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/include/audio_pipe_manager.h b/services/audio_policy/server/domain/pipe/include/audio_pipe_manager.h index 4463a2d54028294cbd035db69a290ee23ccd2e26..ca3ac867f647eff6d0f1b50e31fee64d1c427f8f 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_pipe_manager.h +++ b/services/audio_policy/server/domain/pipe/include/audio_pipe_manager.h @@ -45,7 +45,7 @@ public: bool IsSamePipe(std::shared_ptr info, std::shared_ptr cmpInfo); const std::vector> GetPipeList(); - std::vector> GetUnusedPipe(); + std::vector> GetUnusedPipe(DeviceType curOutputDeviceType); std::vector> GetUnusedRecordPipe(); std::shared_ptr GetPipeinfoByNameAndFlag(const std::string adapterName, const uint32_t routeFlag); std::string GetAdapterNameBySessionId(uint32_t sessionId); @@ -83,6 +83,8 @@ public: void UpdateOutputStreamDescsByIoHandle(AudioIOHandle id, std::vector> &descs); std::vector> GetAllCapturerStreamDescs(); + std::shared_ptr FindPipeBySessionId(const std::vector> &pipeList, + uint32_t sessionId); private: bool IsSpecialPipe(uint32_t routeFlag); diff --git a/services/audio_policy/server/domain/pipe/include/audio_pipe_selector.h b/services/audio_policy/server/domain/pipe/include/audio_pipe_selector.h index 61b7b8b0394ee16419b485f847c1b4f9f5991c30..14b7733ea72571dae0d04204886f539349f4b1e7 100644 --- a/services/audio_policy/server/domain/pipe/include/audio_pipe_selector.h +++ b/services/audio_policy/server/domain/pipe/include/audio_pipe_selector.h @@ -35,14 +35,15 @@ public: std::vector> &streamDescs); private: - void UpdataDeviceStreamInfo(std::shared_ptr &streamDesc, + void UpdateDeviceStreamInfo(std::shared_ptr &streamDesc, std::shared_ptr streamPropInfo); void ScanPipeListForStreamDesc(std::vector> &pipeInfoList, std::shared_ptr streamDesc); - bool ProcessConcurrency(std::shared_ptr stream, - std::shared_ptr cmpStream); - void IncomingConcurrency(std::shared_ptr stream, - std::shared_ptr cmpStream); + bool ProcessConcurrency(std::shared_ptr existingStream, + std::shared_ptr incomingStream, + std::vector> &streamsToMove); + void CheckAndHandleIncomingConcurrency(std::shared_ptr existingStream, + std::shared_ptr incomingStream); uint32_t GetRouteFlagByStreamDesc(std::shared_ptr streamDesc); std::string GetAdapterNameByStreamDesc(std::shared_ptr streamDesc); void ConvertStreamDescToPipeInfo(std::shared_ptr streamDesc, @@ -59,6 +60,14 @@ private: std::vector> &streamDescs); void DecidePipesAndStreamAction(std::vector> &newPipeInfoList, std::map> streamDescToOldPipeInfo); + void MoveStreamsToNormalPipes(std::vector> &streamsToMove, + std::vector> &pipeInfoList); + void RemoveTargetStreams(std::vector> streamsToMove, + std::vector> &pipeInfoList, + std::map, std::string> &streamToAdapter); + void AddStreamToPipeAndUpdateAction(std::shared_ptr &streamToAdd, + std::shared_ptr &pipe); + AudioPolicyConfigManager& configManager_; }; } // namespace AudioStandard diff --git a/services/audio_policy/server/domain/pipe/src/audio_a2dp_offload_manager.cpp b/services/audio_policy/server/domain/pipe/src/audio_a2dp_offload_manager.cpp index 8997695936137b03b49dfc4b90a78b40171009ef..1d0c9e81c0e4c96fedf7c0d9dc3b3625dd82df31 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_a2dp_offload_manager.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_a2dp_offload_manager.cpp @@ -17,22 +17,10 @@ #endif #include "audio_a2dp_offload_manager.h" -#include -#include "iservice_registry.h" -#include "parameter.h" -#include "parameters.h" -#include "audio_utils.h" -#include "audio_policy_log.h" -#include "audio_utils.h" -#include "audio_inner_call.h" -#include "media_monitor_manager.h" -#include "audio_affinity_manager.h" + #include "audio_stream_collector.h" -#include "audio_policy_manager_factory.h" #include "audio_spatialization_manager.h" #include "audio_spatialization_service.h" -#include "audio_router_center.h" - #include "audio_policy_utils.h" #include "audio_server_proxy.h" @@ -43,33 +31,15 @@ const int32_t A2DP_STOPPED = 1; const int32_t DATA_LINK_CONNECTING = 10; const int32_t DATA_LINK_CONNECTED = 11; const int32_t CONNECTION_TIMEOUT_IN_MS = 1000; // 1000ms - -#ifdef BLUETOOTH_ENABLE -const unsigned int BLUETOOTH_TIME_OUT_SECONDS = 8; -#endif - -static std::string GetEncryptAddr(const std::string &addr) -{ - const int32_t START_POS = 6; - const int32_t END_POS = 13; - const int32_t ADDRESS_STR_LEN = 17; - if (addr.empty() || addr.length() != ADDRESS_STR_LEN) { - return std::string(""); - } - std::string tmp = "**:**:**:**:**:**"; - std::string out = addr; - for (int i = START_POS; i <= END_POS; i++) { - out[i] = tmp[i]; - } - return out; -} +const int32_t SESSION_ID_INVALID = 0; void AudioA2dpOffloadManager::OnA2dpPlayingStateChanged(const std::string &deviceAddress, int32_t playingState) { A2dpOffloadConnectionState state = audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(); - AUDIO_INFO_LOG("OnA2dpPlayingStateChanged current A2dpOffload MacAddr:%{public}s, incoming MacAddr:%{public}s, " - "currentStatus:%{public}d, incommingState:%{public}d", GetEncryptAddr(a2dpOffloadDeviceAddress_).c_str(), - GetEncryptAddr(deviceAddress).c_str(), state, playingState); + AUDIO_INFO_LOG("current A2dpOffload MacAddr:%{public}s, incoming MacAddr:%{public}s, " + "currentStatus:%{public}d, incommingState:%{public}d", + AudioPolicyUtils::GetInstance().GetEncryptAddr(a2dpOffloadDeviceAddress_).c_str(), + AudioPolicyUtils::GetInstance().GetEncryptAddr(deviceAddress).c_str(), state, playingState); if (deviceAddress != a2dpOffloadDeviceAddress_) { if (playingState == A2DP_STOPPED && state == CONNECTION_STATUS_CONNECTED) { return; @@ -82,9 +52,7 @@ void AudioA2dpOffloadManager::OnA2dpPlayingStateChanged(const std::string &devic // deviceAddress matched if (playingState == A2DP_PLAYING) { if (state == CONNECTION_STATUS_CONNECTING) { - AUDIO_INFO_LOG("OnA2dpPlayingStateChanged state change " - "from %{public}d to %{public}d", state, CONNECTION_STATUS_CONNECTED); - + AUDIO_INFO_LOG("state change from %{public}d to %{public}d", state, CONNECTION_STATUS_CONNECTED); for (int32_t sessionId : connectionTriggerSessionIds_) { AudioServerProxy::GetInstance().UpdateSessionConnectionStateProxy(sessionId, DATA_LINK_CONNECTED); } @@ -93,23 +61,21 @@ void AudioA2dpOffloadManager::OnA2dpPlayingStateChanged(const std::string &devic } audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); } else if (playingState == A2DP_STOPPED) { - AUDIO_INFO_LOG("OnA2dpPlayingStateChanged state change " - "from %{public}d to %{public}d", state, CONNECTION_STATUS_DISCONNECTED); + AUDIO_INFO_LOG("state change from %{public}d to %{public}d", state, CONNECTION_STATUS_DISCONNECTED); audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_DISCONNECTED); a2dpOffloadDeviceAddress_ = ""; std::vector().swap(connectionTriggerSessionIds_); } else { - // at the current moment, we only handle the PLAYING and STOPPED state, - // will handle other state in the future - AUDIO_INFO_LOG("OnA2dpPlayingStateChanged state: %{public}d, " - "received unexpected state:%{public}d", state, playingState); + // Currently we only handle the PLAYING and STOPPED state, may handle other state in the future + AUDIO_INFO_LOG("state: %{public}d, received unexpected state:%{public}d", state, playingState); } } void AudioA2dpOffloadManager::ConnectA2dpOffload(const std::string &deviceAddress, const std::vector &sessionIds) { - AUDIO_INFO_LOG("start connecting a2dpOffload for MacAddr:%{public}s.", GetEncryptAddr(deviceAddress).c_str()); + AUDIO_INFO_LOG("start connecting a2dpOffload for MacAddr:%{public}s.", + AudioPolicyUtils::GetInstance().GetEncryptAddr(deviceAddress).c_str()); A2dpOffloadConnectionState state = audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(); a2dpOffloadDeviceAddress_ = deviceAddress; connectionTriggerSessionIds_.assign(sessionIds.begin(), sessionIds.end()); @@ -139,7 +105,7 @@ void AudioA2dpOffloadManager::WaitForConnectionCompleted() return audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState() == CONNECTION_STATUS_CONNECTED; }); // a2dp connection timeout, anyway we should notify client dataLink OK in order to allow the data flow begin - AUDIO_INFO_LOG("WaitForConnectionCompleted unblocked, connectionCompleted is %{public}d", connectionCompleted); + AUDIO_INFO_LOG("unblocked, connectionCompleted is %{public}d", connectionCompleted); if (!connectionCompleted) { AUDIO_INFO_LOG("state change from %{public}d to %{public}d", @@ -151,7 +117,6 @@ void AudioA2dpOffloadManager::WaitForConnectionCompleted() std::vector().swap(connectionTriggerSessionIds_); } waitLock.unlock(); - FetchStreamForA2dpOffload(false); return; } @@ -214,179 +179,178 @@ BluetoothOffloadState AudioA2dpOffloadManager::GetA2dpOffloadFlag() return audioA2dpOffloadFlag_.GetA2dpOffloadFlag(); } -void AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForAllStream( - std::unordered_map &sessionIDToSpatializationEnableMap, DeviceType deviceType) +void AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForSpatializationChanged( + std::unordered_map &sessionIDToSpatializationEnabledMap, DeviceType deviceType) +{ + UpdateA2dpOffloadFlagCommon(SESSION_ID_INVALID, deviceType, false, sessionIDToSpatializationEnabledMap); +} + +void AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForStartStream(int32_t startSessionId) +{ + std::unordered_map emptySpatializationMap; + UpdateA2dpOffloadFlagCommon(startSessionId, DEVICE_TYPE_NONE, true, emptySpatializationMap); +} + +uint32_t AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForAllStream(DeviceType deviceType) +{ + std::unordered_map emptySpatializationMap; + uint32_t runningSessionsSize = + UpdateA2dpOffloadFlagCommon(SESSION_ID_INVALID, deviceType, true, emptySpatializationMap); + return runningSessionsSize; +} + +uint32_t AudioA2dpOffloadManager::UpdateA2dpOffloadFlagCommon( + int32_t startSessionId, DeviceType deviceType, bool getSpatialFromService, + std::unordered_map &sessionIDToSpatializationEnabledMap) { #ifdef BLUETOOTH_ENABLE - vector allSessionInfos; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - vector> audioRendererChangeInfos; - streamCollector_.GetCurrentRendererChangeInfos(audioRendererChangeInfos); - std::vector stopPlayingStream(0); - for (auto &changeInfo : audioRendererChangeInfos) { - if (changeInfo->rendererState != RENDERER_RUNNING) { - stopPlayingStream.emplace_back(changeInfo->sessionId); + std::vector> rendererChangeInfos; + streamCollector_.GetCurrentRendererChangeInfos(rendererChangeInfos); + + std::vector allRunningSessions; + std::vector allStopSessions; + std::vector allRunningA2dpInfos; + Bluetooth::A2dpStreamInfo tmpA2dpStreamInfo; + for (auto &changeInfo : rendererChangeInfos) { + if (changeInfo->sessionId != startSessionId && changeInfo->rendererState != RENDERER_RUNNING) { + allStopSessions.push_back(changeInfo->sessionId); continue; } - a2dpStreamInfo.sessionId = changeInfo->sessionId; - a2dpStreamInfo.streamType = streamCollector_.GetStreamType(changeInfo->sessionId); - if (sessionIDToSpatializationEnableMap.count(static_cast(a2dpStreamInfo.sessionId))) { - a2dpStreamInfo.isSpatialAudio = - sessionIDToSpatializationEnableMap[static_cast(a2dpStreamInfo.sessionId)]; - } else { - a2dpStreamInfo.isSpatialAudio = 0; - } - allSessionInfos.push_back(a2dpStreamInfo); + allRunningSessions.push_back(changeInfo->sessionId); + + // Generate a2dp info + tmpA2dpStreamInfo.sessionId = changeInfo->sessionId; + tmpA2dpStreamInfo.streamType = streamCollector_.GetStreamType(changeInfo->sessionId); + tmpA2dpStreamInfo.isSpatialAudio = GetSpatialAudio(getSpatialFromService, + changeInfo->sessionId, changeInfo->rendererInfo.streamUsage, + sessionIDToSpatializationEnabledMap); + + allRunningA2dpInfos.push_back(tmpA2dpStreamInfo); } - if (stopPlayingStream.size() > 0) { - OffloadStopPlaying(stopPlayingStream); + if (allStopSessions.size() > 0) { + OffloadStopPlaying(allStopSessions); } - UpdateA2dpOffloadFlag(allSessionInfos, deviceType); + + UpdateA2dpOffloadFlagInternal(allRunningA2dpInfos, allRunningSessions, deviceType); + + return allRunningSessions.size(); #endif - AUDIO_DEBUG_LOG("deviceType %{public}d", deviceType); + return 0; } -int32_t AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForAllStream(DeviceType deviceType) +bool AudioA2dpOffloadManager::GetSpatialAudio(bool getSpatialFromService, + int32_t sessionId, StreamUsage usage, + std::unordered_map &sessionIDToSpatializationEnabledMap) { - int32_t activeSessionsSize = 0; -#ifdef BLUETOOTH_ENABLE - vector allSessionInfos; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - vector> audioRendererChangeInfos; - streamCollector_.GetCurrentRendererChangeInfos(audioRendererChangeInfos); - { - AudioXCollie audioXCollie("AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForAllStream", - BLUETOOTH_TIME_OUT_SECONDS, nullptr, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY); - std::vector stopPlayingStream(0); - for (auto &changeInfo : audioRendererChangeInfos) { - if (changeInfo->rendererState != RENDERER_RUNNING) { - stopPlayingStream.emplace_back(changeInfo->sessionId); - continue; - } - a2dpStreamInfo.sessionId = changeInfo->sessionId; - a2dpStreamInfo.streamType = streamCollector_.GetStreamType(changeInfo->sessionId); - StreamUsage tempStreamUsage = changeInfo->rendererInfo.streamUsage; - AudioSpatializationState spatialState = - AudioSpatializationService::GetAudioSpatializationService().GetSpatializationState(tempStreamUsage); - a2dpStreamInfo.isSpatialAudio = spatialState.spatializationEnabled; - allSessionInfos.push_back(a2dpStreamInfo); - } - if (stopPlayingStream.size() > 0) { - OffloadStopPlaying(stopPlayingStream); + bool isSpatial = false; + if (getSpatialFromService) { + // Get spatial from service may meet dead lock, use this case carefully + AudioSpatializationState spatialState = + AudioSpatializationService::GetAudioSpatializationService().GetSpatializationState(usage); + isSpatial = spatialState.spatializationEnabled; + } else { + if (sessionIDToSpatializationEnabledMap.count(static_cast(sessionId))) { + isSpatial = sessionIDToSpatializationEnabledMap[static_cast(sessionId)]; + } else { + isSpatial = false; } } - UpdateA2dpOffloadFlag(allSessionInfos, deviceType); - activeSessionsSize = static_cast(allSessionInfos.size()); -#endif - AUDIO_DEBUG_LOG("deviceType %{public}d", deviceType); - return activeSessionsSize; + return isSpatial; } -void AudioA2dpOffloadManager::UpdateOffloadWhenActiveDeviceSwitchFromA2dp() +void AudioA2dpOffloadManager::UpdateA2dpOffloadFlagForA2dpDeviceOut() { - AUDIO_PRERELEASE_LOGI("a2dpOffloadFlag change from %{public}d to %{public}d", GetA2dpOffloadFlag(), - NO_A2DP_DEVICE); - std::vector allSessions; - GetAllRunningStreamSession(allSessions); - OffloadStopPlaying(allSessions); - SetA2dpOffloadFlag(NO_A2DP_DEVICE); - for (auto it = allSessions.begin(); it != allSessions.end(); ++it) { - audioOffloadStream_.ResetOffloadMode(*it); + AUDIO_PRERELEASE_LOGI("a2dpOffloadFlag change from %{public}d to %{public}d", + GetA2dpOffloadFlag(), NO_A2DP_DEVICE); + + // Get current running stream sessions to stop + std::vector allRunningSessions; + std::vector> rendererChangeInfos; + streamCollector_.GetCurrentRendererChangeInfos(rendererChangeInfos); + for (auto &changeInfo : rendererChangeInfos) { + if (changeInfo->rendererState != RENDERER_RUNNING) { + continue; + } + allRunningSessions.push_back(changeInfo->sessionId); } + OffloadStopPlaying(allRunningSessions); + SetA2dpOffloadFlag(NO_A2DP_DEVICE); } #ifdef BLUETOOTH_ENABLE -void AudioA2dpOffloadManager::UpdateA2dpOffloadFlag(const std::vector &allActiveSessions, - DeviceType deviceType) +void AudioA2dpOffloadManager::UpdateA2dpOffloadFlagInternal( + const std::vector &allRunningA2dpInfos, + std::vector &allRunningSessions, DeviceType deviceType) { - if (allActiveSessions.size() == 0) { + if (allRunningA2dpInfos.size() == 0) { return; } - auto receiveOffloadFlag = NO_A2DP_DEVICE; + BluetoothOffloadState newA2dpOffloadFlag = NO_A2DP_DEVICE; + BluetoothOffloadState oldA2dpOffloadFlag = GetA2dpOffloadFlag(); if (deviceType == DEVICE_TYPE_BLUETOOTH_A2DP) { - receiveOffloadFlag = static_cast(Bluetooth::AudioA2dpManager::A2dpOffloadSessionRequest( - allActiveSessions)); + newA2dpOffloadFlag = static_cast( + Bluetooth::AudioA2dpManager::A2dpOffloadSessionRequest(allRunningA2dpInfos)); } else if (audioActiveDevice_.GetCurrentOutputDeviceType() == DEVICE_TYPE_BLUETOOTH_A2DP && audioActiveDevice_.GetCurrentOutputDeviceNetworkId() == LOCAL_NETWORK_ID && deviceType == DEVICE_TYPE_NONE) { - receiveOffloadFlag = static_cast(Bluetooth::AudioA2dpManager::A2dpOffloadSessionRequest( - allActiveSessions)); + newA2dpOffloadFlag = static_cast( + Bluetooth::AudioA2dpManager::A2dpOffloadSessionRequest(allRunningA2dpInfos)); } std::lock_guard lock(switchA2dpOffloadMutex_); - AUDIO_PRERELEASE_LOGI("deviceType: %{public}d, currentActiveDevice_: %{public}d, allActiveSessions: %{public}zu, " - "a2dpOffloadFlag: %{public}d, receiveOffloadFlag: %{public}d", - deviceType, audioActiveDevice_.GetCurrentOutputDeviceType(), allActiveSessions.size(), GetA2dpOffloadFlag(), - receiveOffloadFlag); - - if (receiveOffloadFlag == NO_A2DP_DEVICE) { - UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); - } else if (receiveOffloadFlag != GetA2dpOffloadFlag()) { - if (GetA2dpOffloadFlag() == A2DP_OFFLOAD) { - HandleA2dpDeviceOutOffload(receiveOffloadFlag); - } else if (receiveOffloadFlag == A2DP_OFFLOAD) { - HandleA2dpDeviceInOffload(receiveOffloadFlag); + AUDIO_PRERELEASE_LOGI("device: %{public}d, currentOutputDevice: %{public}d, runningStreamSize: %{public}zu, " + "oldA2dpOffloadFlag: %{public}d, newA2dpOffloadFlag: %{public}d", + deviceType, audioActiveDevice_.GetCurrentOutputDeviceType(), allRunningA2dpInfos.size(), + oldA2dpOffloadFlag, newA2dpOffloadFlag); + + if (newA2dpOffloadFlag == NO_A2DP_DEVICE) { + UpdateA2dpOffloadFlagForA2dpDeviceOut(); + } else if (newA2dpOffloadFlag != oldA2dpOffloadFlag) { + if (oldA2dpOffloadFlag == A2DP_OFFLOAD) { + HandleA2dpDeviceOutOffload(newA2dpOffloadFlag, allRunningSessions); + } else if (newA2dpOffloadFlag == A2DP_OFFLOAD) { + HandleA2dpDeviceInOffload(newA2dpOffloadFlag, allRunningSessions); } else { - AUDIO_INFO_LOG("a2dpOffloadFlag change from %{public}d to %{public}d", GetA2dpOffloadFlag(), - receiveOffloadFlag); - SetA2dpOffloadFlag(receiveOffloadFlag); + // Only NO_A2DP_DEVICE to A2DP_NOT_OFFLOAD case + AUDIO_INFO_LOG("a2dpOffloadFlag change from %{public}d to %{public}d", + oldA2dpOffloadFlag, newA2dpOffloadFlag); + SetA2dpOffloadFlag(newA2dpOffloadFlag); } - } else if (GetA2dpOffloadFlag() == A2DP_OFFLOAD) { - std::vector allSessions; - GetAllRunningStreamSession(allSessions); - OffloadStartPlaying(allSessions); + } else if (oldA2dpOffloadFlag == A2DP_OFFLOAD) { + OffloadStartPlaying(allRunningSessions); AudioServerProxy::GetInstance().UpdateEffectBtOffloadSupportedProxy(true); - audioOffloadStream_.ResetOffloadModeOnSpatializationChanged(allSessions); GetA2dpOffloadCodecAndSendToDsp(); - std::string activePort = BLUETOOTH_SPEAKER; - audioPolicyManager_.SuspendAudioDevice(activePort, true); } } - #endif -int32_t AudioA2dpOffloadManager::HandleA2dpDeviceOutOffload(BluetoothOffloadState a2dpOffloadFlag) +int32_t AudioA2dpOffloadManager::HandleA2dpDeviceOutOffload(BluetoothOffloadState a2dpOffloadFlag, + std::vector &allRunningSessions) { #ifdef BLUETOOTH_ENABLE AUDIO_INFO_LOG("a2dpOffloadFlag change from %{public}d to %{public}d", GetA2dpOffloadFlag(), a2dpOffloadFlag); - std::vector allSessions; - GetAllRunningStreamSession(allSessions); - OffloadStopPlaying(allSessions); - SetA2dpOffloadFlag(a2dpOffloadFlag); - - DeviceType dev = audioActiveDevice_.GetCurrentOutputDeviceType(); - AUDIO_INFO_LOG("Handle A2dpDevice Out Offload"); - FetchStreamForA2dpOffload(true); + OffloadStopPlaying(allRunningSessions); + SetA2dpOffloadFlag(a2dpOffloadFlag); - AudioDeviceDescriptor deviceDescriptor = audioActiveDevice_.GetCurrentOutputDevice(); - if (deviceDescriptor.deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) { - return HandleActiveDevice(deviceDescriptor); - } else { - return SUCCESS; - } + return SUCCESS; #else return ERROR; #endif } -int32_t AudioA2dpOffloadManager::HandleA2dpDeviceInOffload(BluetoothOffloadState a2dpOffloadFlag) +int32_t AudioA2dpOffloadManager::HandleA2dpDeviceInOffload(BluetoothOffloadState a2dpOffloadFlag, + std::vector &allRunningSessions) { #ifdef BLUETOOTH_ENABLE AUDIO_INFO_LOG("a2dpOffloadFlag change from %{public}d to %{public}d", GetA2dpOffloadFlag(), a2dpOffloadFlag); + SetA2dpOffloadFlag(a2dpOffloadFlag); GetA2dpOffloadCodecAndSendToDsp(); - std::vector allSessions; - GetAllRunningStreamSession(allSessions); - OffloadStartPlaying(allSessions); - DeviceType dev = audioActiveDevice_.GetCurrentOutputDeviceType(); - AUDIO_INFO_LOG("Handle A2dpDevice In Offload"); + OffloadStartPlaying(allRunningSessions); + AudioServerProxy::GetInstance().UpdateEffectBtOffloadSupportedProxy(true); - if (IsA2dpOffloadConnected()) { - AUDIO_INFO_LOG("A2dpOffload has been connected, Fetch stream"); - FetchStreamForA2dpOffload(true); - } return SUCCESS; #else return ERROR; @@ -432,112 +396,5 @@ void AudioA2dpOffloadManager::GetA2dpOffloadCodecAndSendToDsp() AUDIO_INFO_LOG("update offloadcodec[%{public}s]", value.c_str()); #endif } - -int32_t AudioA2dpOffloadManager::HandleActiveDevice(AudioDeviceDescriptor deviceDescriptor) -{ - AudioDeviceDescriptor curOutputDevice = audioActiveDevice_.GetCurrentOutputDevice(); - if (GetVolumeGroupType(curOutputDevice.deviceType_) != GetVolumeGroupType(deviceDescriptor.deviceType_)) { - audioVolumeManager_.SetVolumeForSwitchDevice(deviceDescriptor); - } - if (audioConfigManager_.GetUpdateRouteSupport()) { - audioActiveDevice_.UpdateActiveDeviceRoute(deviceDescriptor.deviceType_, DeviceFlag::OUTPUT_DEVICES_FLAG, - deviceDescriptor.deviceName_, deviceDescriptor.networkId_); - } - std::string sinkPortName = AudioPolicyUtils::GetInstance().GetSinkPortName(deviceDescriptor.deviceType_); - std::string sourcePortName = AudioPolicyUtils::GetInstance().GetSourcePortName(deviceDescriptor.deviceType_); - if (sinkPortName == PORT_NONE && sourcePortName == PORT_NONE) { - AUDIO_ERR_LOG("failed for sinkPortName and sourcePortName are none"); - return ERR_OPERATION_FAILED; - } - if (sinkPortName != PORT_NONE) { - audioIOHandleMap_.GetSinkIOHandle(deviceDescriptor.deviceType_); - audioPolicyManager_.SuspendAudioDevice(sinkPortName, false); - } - if (sourcePortName != PORT_NONE) { - audioIOHandleMap_.GetSourceIOHandle(deviceDescriptor.deviceType_); - audioPolicyManager_.SuspendAudioDevice(sourcePortName, false); - } - - return SUCCESS; -} - -void AudioA2dpOffloadManager::FetchStreamForA2dpOffload(const bool &requireReset) -{ - vector> rendererChangeInfos; - streamCollector_.GetCurrentRendererChangeInfos(rendererChangeInfos); - AUDIO_INFO_LOG("FetchStreamForA2dpOffload start for %{public}zu stream", rendererChangeInfos.size()); - for (auto &rendererChangeInfo : rendererChangeInfos) { - if (!audioDeviceCommon_.IsRendererStreamRunning(rendererChangeInfo)) { - continue; - } - vector> descs = - audioRouterCenter_.FetchOutputDevices(rendererChangeInfo->rendererInfo.streamUsage, - rendererChangeInfo->clientUID, "FetchStreamForA2dpOffload"); - - if (descs.front()->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) { - if (requireReset) { - int32_t ret = audioDeviceCommon_.ActivateA2dpDevice(descs.front(), rendererChangeInfos); - CHECK_AND_RETURN_LOG(ret == SUCCESS, "activate a2dp [%{public}s] failed", - GetEncryptAddr(descs.front()->macAddress_).c_str()); - std::string activePort = BLUETOOTH_SPEAKER; - audioPolicyManager_.SuspendAudioDevice(activePort, true); - } - if (rendererChangeInfo->rendererInfo.rendererFlags == AUDIO_FLAG_MMAP) { - AudioServerProxy::GetInstance().ResetAudioEndpointProxy(); - } - audioDeviceCommon_.FetchStreamForA2dpMchStream(rendererChangeInfo, descs); - } - } -} - -void AudioA2dpOffloadManager::GetAllRunningStreamSession(std::vector &allSessions, bool doStop) -{ -#ifdef BLUETOOTH_ENABLE - std::vector> rendererChangeInfos; - streamCollector_.GetCurrentRendererChangeInfos(rendererChangeInfos); - std::vector stopPlayingStream(0); - for (auto &changeInfo : rendererChangeInfos) { - if (changeInfo->rendererState != RENDERER_RUNNING) { - if (doStop) { - stopPlayingStream.push_back(changeInfo->sessionId); - } - continue; - } - allSessions.push_back(changeInfo->sessionId); - } - if (doStop && stopPlayingStream.size() > 0) { - OffloadStopPlaying(stopPlayingStream); - } -#endif -} - -std::string AudioA2dpOffloadManager::GetVolumeGroupType(DeviceType deviceType) -{ - std::string volumeGroupType = ""; - switch (deviceType) { - case DEVICE_TYPE_EARPIECE: - case DEVICE_TYPE_SPEAKER: - case DEVICE_TYPE_DP: - case DEVICE_TYPE_HDMI: - volumeGroupType = "build-in"; - break; - case DEVICE_TYPE_BLUETOOTH_A2DP: - case DEVICE_TYPE_BLUETOOTH_SCO: - case DEVICE_TYPE_ACCESSORY: - volumeGroupType = "wireless"; - break; - case DEVICE_TYPE_WIRED_HEADSET: - case DEVICE_TYPE_WIRED_HEADPHONES: - case DEVICE_TYPE_USB_HEADSET: - case DEVICE_TYPE_USB_ARM_HEADSET: - volumeGroupType = "wired"; - break; - default: - AUDIO_ERR_LOG("device %{public}d is not supported", deviceType); - break; - } - return volumeGroupType; -} - -} -} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/domain/pipe/src/audio_capturer_session.cpp b/services/audio_policy/server/domain/pipe/src/audio_capturer_session.cpp index da6455cb1eff024fe78c4f07323ecd5ece06a90e..8dfde796ca17fc6fc45ee65aa536bd7222981e62 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_capturer_session.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_capturer_session.cpp @@ -37,6 +37,7 @@ const uint32_t PCM_8_BIT = 8; const float RENDER_FRAME_INTERVAL_IN_SECONDS = 0.02; const std::string PIPE_PRIMARY_INPUT = "primary_input"; const std::string PIPE_WAKEUP_INPUT = "wakeup_input"; +const std::string PIPE_PRIMARY_INPUT_AI = "primary_input_AI"; inline const std::unordered_set specialSourceTypeSet_ = { SOURCE_TYPE_PLAYBACK_CAPTURE, @@ -186,35 +187,115 @@ void AudioCapturerSession::HandleRemoteCastDevice(bool isConnected, AudioStreamI #endif } -bool AudioCapturerSession::FindRunningNormalSession(uint32_t sessionId, AudioCapturerChangeInfo &runningSessionInfo) +bool AudioCapturerSession::IsInvalidPipeRole(const std::shared_ptr &pipe) { - bool hasSession = false; - SourceType tmpSource = SOURCE_TYPE_INVALID; - AudioStreamCollector &streamCollector = AudioStreamCollector::GetAudioStreamCollector(); - std::vector> capturerChangeInfos; - streamCollector.GetCurrentCapturerChangeInfos(capturerChangeInfos); + return pipe->pipeRole_ != PIPE_ROLE_INPUT; +} + +bool AudioCapturerSession::CompareIndependentxmlPriority(const std::shared_ptr &pipe, + uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo, bool &hasSession) +{ + auto sourceStrategyMap = AudioSourceStrategyData::GetInstance().GetSourceStrategyMap(); + if (sourceStrategyMap == nullptr) { + return false; + } - for (const auto &info : capturerChangeInfos) { - if (!info || sessionWithNormalSourceType_.find(info->sessionId) == sessionWithNormalSourceType_.end()) { + uint32_t maxPriority = 0; + for (const auto &stream : pipe->streamDescriptors_) { + if (stream == nullptr || stream->sessionId_ == sessionId || stream->streamStatus_ != STREAM_STATUS_STARTED) { continue; } - tmpSource = sessionWithNormalSourceType_[info->sessionId].sourceType; - if (info->capturerState != CAPTURER_RUNNING || static_cast(info->sessionId) == sessionId || - specialSourceTypeSet_.count(tmpSource) != 0) { + + auto strategyIt = sourceStrategyMap->find(stream->capturerInfo_.sourceType); + if (strategyIt == sourceStrategyMap->end()) { continue; } - if (IsHigherPrioritySourceType(tmpSource, runningSessionInfo.capturerInfo.sourceType)) { + + if (strategyIt->second.priority > maxPriority) { + maxPriority = strategyIt->second.priority; + stream->CopyToStruct(runningSessionInfo); hasSession = true; - runningSessionInfo = *info; } } + AUDIO_INFO_LOG("Independent find ret: %{public}d, session: %{public}d, sourceType: %{public}d", + static_cast(hasSession), runningSessionInfo.sessionId_, runningSessionInfo.capturerInfo_.sourceType); + return hasSession; +} - AUDIO_INFO_LOG("find ret: %{public}d, session: %{public}d, sourceType: %{public}d", - static_cast(hasSession), runningSessionInfo.sessionId, runningSessionInfo.capturerInfo.sourceType); +bool AudioCapturerSession::HandleIndependentInputpipe(const std::vector> &pipeList, + uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo, bool &hasSession) +{ + for (const auto &pipe : pipeList) { + if (pipe && pipe->pipeRole_ == PIPE_ROLE_INPUT && pipe->routeFlag_ == AUDIO_INPUT_FLAG_AI) { + AUDIO_INFO_LOG("In Independent pipe"); + return CompareIndependentxmlPriority(pipe, sessionId, runningSessionInfo, hasSession); + } + } + return hasSession; +} + +bool AudioCapturerSession::HandleNormalInputPipes(const std::vector> &pipeList, + uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo, bool &hasSession) +{ + AUDIO_INFO_LOG("normal input"); + for (const auto &pipe : pipeList) { + if (pipe == nullptr || pipe->pipeRole_ != PIPE_ROLE_INPUT) { + continue; + } + + uint32_t flagMask = AUDIO_INPUT_FLAG_AI | AUDIO_INPUT_FLAG_FAST; + if ((pipe->routeFlag_ & flagMask) != 0) { + continue; + } + + for (const auto &stream : pipe->streamDescriptors_) { + if (stream == nullptr || stream->sessionId_ == sessionId || IsStreamValid(stream) == false) { + continue; + } + SourceType tmpSource = sessionWithNormalSourceType_[stream->sessionId_].sourceType; + if (IsHigherPrioritySourceType(tmpSource, runningSessionInfo.capturerInfo_.sourceType)) { + hasSession = true; + stream->CopyToStruct(runningSessionInfo); + } + } + } + AUDIO_INFO_LOG("find ret: %{public}d, session: %{public}d, sourceType: %{public}d", + static_cast(hasSession), runningSessionInfo.sessionId_, runningSessionInfo.capturerInfo_.sourceType); return hasSession; } +bool AudioCapturerSession::IsStreamValid(const std::shared_ptr &stream) +{ + return sessionWithNormalSourceType_.find(stream->sessionId_) != sessionWithNormalSourceType_.end() && + stream->streamStatus_ == STREAM_STATUS_STARTED && + specialSourceTypeSet_.count(sessionWithNormalSourceType_[stream->sessionId_].sourceType) == 0; +} + +bool AudioCapturerSession::FindRunningNormalSession(uint32_t sessionId, AudioStreamDescriptor &runningSessionInfo) +{ + bool hasSession = false; + SourceType tmpSource = SOURCE_TYPE_INVALID; + + const std::vector> pipeList = AudioPipeManager::GetPipeManager()->GetPipeList(); + std::shared_ptr incommingPipe = + AudioPipeManager::GetPipeManager()->FindPipeBySessionId(pipeList, sessionId); + if (incommingPipe == nullptr) { + return false; + } + + AUDIO_INFO_LOG("incommingPipe: %{public}s", incommingPipe->name_.c_str()); + if (IsInvalidPipeRole(incommingPipe)) { + return false; + } + + if (incommingPipe->routeFlag_ == AUDIO_INPUT_FLAG_AI) { + return HandleIndependentInputpipe(pipeList, sessionId, runningSessionInfo, hasSession); + } + + return HandleNormalInputPipes(pipeList, sessionId, runningSessionInfo, hasSession); +} + int32_t AudioCapturerSession::ReloadCaptureSessionSoftLink() { std::lock_guard lock(onCapturerSessionChangedMutex_); @@ -222,7 +303,7 @@ int32_t AudioCapturerSession::ReloadCaptureSessionSoftLink() auto pipes = AudioPipeManager::GetPipeManager()->GetPipeList(); if (pipes.empty()) { AUDIO_ERR_LOG("pipes invalid"); - return hasSession; + return ERR_INVALID_OPERATION; } AudioStreamDescriptor targetStream; for (auto pipe : pipes) { @@ -249,12 +330,12 @@ int32_t AudioCapturerSession::ReloadCaptureSessionSoftLink() } if (IsHigherPrioritySourceType(higherSourceType, targetStream.capturerInfo_.sourceType)) { hasSession = true; - targetStream = *streamDescriptor; + streamDescriptor->CopyToStruct(targetStream); } } } - CHECK_AND_RETURN_RET_LOG(hasSession, ERROR, "no need to reload session"); + CHECK_AND_RETURN_RET_LOG(hasSession, SUCCESS, "no need to reload session"); AUDIO_INFO_LOG("start reload session: %{public}u", targetStream.sessionId_); audioEcManager_.ReloadSourceForSession(sessionWithNormalSourceType_[targetStream.sessionId_]); @@ -267,7 +348,7 @@ int32_t AudioCapturerSession::ReloadCaptureSession(uint32_t sessionId, SessionOp AUDIO_INFO_LOG("prepare reload session: %{public}u with operation: %{public}d", sessionId, operation); std::lock_guard lock(onCapturerSessionChangedMutex_); uint32_t targetSessionId = sessionId; - AudioCapturerChangeInfo runningSessionInfo = {}; + AudioStreamDescriptor runningSessionInfo = {}; bool needReload = false; if (sessionWithNormalSourceType_.count(sessionId) == 0 || @@ -281,7 +362,7 @@ int32_t AudioCapturerSession::ReloadCaptureSession(uint32_t sessionId, SessionOp switch (operation) { case SESSION_OPERATION_START: if (findRunningSessionRet && - IsHigherPrioritySourceType(targetSession.sourceType, runningSessionInfo.capturerInfo.sourceType)) { + IsHigherPrioritySourceType(targetSession.sourceType, runningSessionInfo.capturerInfo_.sourceType)) { needReload = true; } else if (!findRunningSessionRet && (audioEcManager_.GetSourceOpened() != targetSession.sourceType)) { needReload = true; @@ -291,7 +372,7 @@ int32_t AudioCapturerSession::ReloadCaptureSession(uint32_t sessionId, SessionOp case SESSION_OPERATION_STOP: if (findRunningSessionRet && (targetSession.sourceType == audioEcManager_.GetSourceOpened())) { needReload = true; - targetSessionId = static_cast(runningSessionInfo.sessionId); + targetSessionId = runningSessionInfo.sessionId_; targetSession = sessionWithNormalSourceType_[targetSessionId]; } break; @@ -337,6 +418,21 @@ int32_t AudioCapturerSession::OnCapturerSessionAdded(uint64_t sessionID, Session return SUCCESS; } +bool AudioCapturerSession::IsRemainingSourceIndependent() +{ + auto sourceStrategyMapget = AudioSourceStrategyData::GetInstance().GetSourceStrategyMap(); + CHECK_AND_RETURN_RET(sourceStrategyMapget != nullptr, false); + for (auto it = sessionWithNormalSourceType_.begin(); it !=sessionWithNormalSourceType_.end(); it++) { + SourceType sourceType = it->second.sourceType; + auto smapIt = sourceStrategyMapget->find(sourceType); + CHECK_AND_RETURN_RET_LOG(smapIt != sourceStrategyMapget->end(), false, + "not find sourceType:%{public}d", sourceType); + CHECK_AND_RETURN_RET_LOG(smapIt->second.pipeName == PIPE_PRIMARY_INPUT_AI, false, + "invalid pipeName:%{public}s", smapIt->second.pipeName.c_str()); + } + return true; +} + void AudioCapturerSession::OnCapturerSessionRemoved(uint64_t sessionID) { std::lock_guard lock(onCapturerSessionChangedMutex_); @@ -354,7 +450,7 @@ void AudioCapturerSession::OnCapturerSessionRemoved(uint64_t sessionID) audioEcManager_.ResetAudioEcInfo(); } sessionWithNormalSourceType_.erase(sessionID); - if (!sessionWithNormalSourceType_.empty()) { + if (!sessionWithNormalSourceType_.empty() && !IsRemainingSourceIndependent()) { return; } // close source when all capturer sessions removed diff --git a/services/audio_policy/server/domain/pipe/src/audio_concurrency_service.cpp b/services/audio_policy/server/domain/pipe/src/audio_concurrency_service.cpp index b75cdfa4942cc8666a5044610ba10fd3229083d3..eeb38226a2a1d4e0896c70aabfbef861e7412c59 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_concurrency_service.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_concurrency_service.cpp @@ -33,9 +33,16 @@ void AudioConcurrencyService::Init() CHECK_AND_RETURN_LOG(!parser->LoadConfig(concurrencyCfgMap_), "Load audioConcurrency cfgMap failed!"); } -std::map, ConcurrencyAction>& AudioConcurrencyService::GetConcurrencyMap() +ConcurrencyAction AudioConcurrencyService::GetConcurrencyAction( + const AudioPipeType existingPipe, const AudioPipeType commingPipe) { - return concurrencyCfgMap_; + auto target = std::make_pair(existingPipe, commingPipe); + if (concurrencyCfgMap_.find(target) == concurrencyCfgMap_.end()) { + AUDIO_ERR_LOG("Can not find matching action for existingPipe %{public}d and commingPipe %{public}d", + existingPipe, commingPipe); + return PLAY_BOTH; + } + return concurrencyCfgMap_[target]; } } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/src/audio_definition_adapter_info.cpp b/services/audio_policy/server/domain/pipe/src/audio_definition_adapter_info.cpp index b2cb6d4548501ee74e268c47535cd962c32b83e6..a36f78ac58fbe8e77107d60792d2f51feb5f957c 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_definition_adapter_info.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_definition_adapter_info.cpp @@ -380,5 +380,24 @@ void PipeStreamPropInfo::SelfCheck() } } +AudioSourceStrategyData& AudioSourceStrategyData::GetInstance() +{ + static AudioSourceStrategyData instance; + return instance; +} + +void AudioSourceStrategyData::SetSourceStrategyMap(std::shared_ptr> newMap) +{ + std::lock_guard lock(mutex_); + sourceStrategyMap_ = newMap; } + +std::shared_ptr> AudioSourceStrategyData::GetSourceStrategyMap() const +{ + std::lock_guard lock(mutex_); + return sourceStrategyMap_; +} + } +} \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/src/audio_definition_policy_utils.cpp b/services/audio_policy/server/domain/pipe/src/audio_definition_policy_utils.cpp index 8f979ef70de87ac0f706cb1e668cefe4a86cac17..caa3430f3751c0c61f99f6ea2b7468f15bacd1d0 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_definition_policy_utils.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_definition_policy_utils.cpp @@ -169,6 +169,7 @@ std::unordered_map AudioDefinitionPolicyUtils::flagStrTo {"AUDIO_INPUT_FLAG_VOIP", AUDIO_INPUT_FLAG_VOIP}, {"AUDIO_INPUT_FLAG_VOIP_FAST", AUDIO_INPUT_FLAG_VOIP_FAST}, {"AUDIO_INPUT_FLAG_WAKEUP", AUDIO_INPUT_FLAG_WAKEUP}, + {"AUDIO_INPUT_FLAG_AI", AUDIO_INPUT_FLAG_AI}, }; std::unordered_map AudioDefinitionPolicyUtils::preloadStrToEnum = { diff --git a/services/audio_policy/server/domain/pipe/src/audio_ec_manager.cpp b/services/audio_policy/server/domain/pipe/src/audio_ec_manager.cpp index c1ec4be4ea61815051a9c77506f968c95c51daa6..9c57e2b99b3e0258dee373344f45f1757db42523 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_ec_manager.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_ec_manager.cpp @@ -227,6 +227,7 @@ void AudioEcManager::UpdateStreamCommonInfo(AudioModuleInfo &moduleInfo, PipeStr moduleInfo.bufferSize = std::to_string(targetInfo.bufferSize_); moduleInfo.format = AudioDefinitionPolicyUtils::enumToFormatStr[targetInfo.format_]; moduleInfo.sourceType = std::to_string(sourceType); + moduleInfo.channelLayout = std::to_string(targetInfo.channelLayout_); } else { shared_ptr inputDesc = audioRouterCenter_.FetchInputDevice(sourceType, -1); if (inputDesc != nullptr && inputDesc->deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET) { @@ -240,6 +241,7 @@ void AudioEcManager::UpdateStreamCommonInfo(AudioModuleInfo &moduleInfo, PipeStr moduleInfo.bufferSize = std::to_string(targetInfo.bufferSize_); moduleInfo.format = AudioDefinitionPolicyUtils::enumToFormatStr[targetInfo.format_]; moduleInfo.sourceType = std::to_string(sourceType); + moduleInfo.channelLayout = std::to_string(targetInfo.channelLayout_); if (inputDesc != nullptr) { moduleInfo.deviceType = std::to_string(static_cast(inputDesc->deviceType_)); } @@ -247,6 +249,7 @@ void AudioEcManager::UpdateStreamCommonInfo(AudioModuleInfo &moduleInfo, PipeStr primaryMicModuleInfo_.channels = std::to_string(targetInfo.channels_); primaryMicModuleInfo_.rate = std::to_string(targetInfo.sampleRate_); primaryMicModuleInfo_.format = AudioDefinitionPolicyUtils::enumToFormatStr[targetInfo.format_]; + primaryMicModuleInfo_.channelLayout = std::to_string(targetInfo.channelLayout_); } } } diff --git a/services/audio_policy/server/domain/pipe/src/audio_offload_stream.cpp b/services/audio_policy/server/domain/pipe/src/audio_offload_stream.cpp index 6f22a8c40bea53d5072a97fd95c643aefee09ce0..ec87be5ed288189e3f39aa5f93e45fc1c2914436 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_offload_stream.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_offload_stream.cpp @@ -17,459 +17,111 @@ #endif #include "audio_offload_stream.h" -#include -#include "iservice_registry.h" -#include "parameter.h" -#include "parameters.h" -#include "audio_policy_log.h" -#include "media_monitor_manager.h" -#include "audio_spatialization_service.h" -#include "audio_policy_utils.h" +#include "audio_policy_log.h" #include "audio_server_proxy.h" namespace OHOS { namespace AudioStandard { -const int32_t UID_AUDIO = 1041; -const int32_t dAudioClientUid = 3055; -static const int32_t WAIT_OFFLOAD_CLOSE_TIME_S = 10; // 10s -static const int32_t SELECT_PIPE_TYPE_OFFLOAD_MUTE_US = 200000; // 200ms - -inline std::string PrintSinkInput(SinkInput sinkInput) -{ - std::stringstream value; - value << "streamId:[" << sinkInput.streamId << "] "; - value << "streamType:[" << sinkInput.streamType << "] "; - value << "uid:[" << sinkInput.uid << "] "; - value << "pid:[" << sinkInput.pid << "] "; - value << "statusMark:[" << sinkInput.statusMark << "] "; - value << "sinkName:[" << sinkInput.sinkName << "] "; - value << "startTime:[" << sinkInput.startTime << "]"; - return value.str(); -} - -void AudioOffloadStream::HandlePowerStateChanged(PowerMgr::PowerState state) -{ - if (currentPowerState_ == state) { - return; - } - currentPowerState_ = state; - if (!audioActiveDevice_.CheckActiveOutputDeviceSupportOffload()) { - return; - } - if (offloadSessionID_.has_value()) { - AUDIO_DEBUG_LOG("SetOffloadMode! Offload power is state = %{public}d", state); - SetOffloadMode(); - } -} - -void AudioOffloadStream::SetOffloadAvailableFromXML(AudioModuleInfo &moduleInfo) -{ - isOffloadAvailable_ = true; -} +const int32_t UID_DAUDIO = 3055; -bool AudioOffloadStream::GetOffloadAvailableFromXml() const +uint32_t AudioOffloadStream::GetOffloadSessionId(OffloadAdapter offloadAdapter) { - return isOffloadAvailable_; + return offloadSessionIdMap_[offloadAdapter]; } -void AudioOffloadStream::SetOffloadMode() +void AudioOffloadStream::SetOffloadStatus(OffloadAdapter offloadAdapter, uint32_t sessionId) { - if (!GetOffloadAvailableFromXml()) { - AUDIO_INFO_LOG("Offload not available, skipped"); - return; - } - - AUDIO_INFO_LOG("sessionId: %{public}d, PowerState: %{public}d, isAppBack: %{public}d", - *offloadSessionID_, static_cast(currentPowerState_), currentOffloadSessionIsBackground_); - AudioServerProxy::GetInstance().SetOffloadModeProxy(*offloadSessionID_, static_cast(currentPowerState_), - currentOffloadSessionIsBackground_); -} - -void AudioOffloadStream::OffloadStreamSetCheck(uint32_t sessionId) -{ - AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); - std::string curOutputNetworkId = audioActiveDevice_.GetCurrentOutputDeviceNetworkId(); - std::string curOutputMacAddr = audioActiveDevice_.GetCurrentOutputDeviceMacAddr(); - DeviceType curOutputDeviceType = audioActiveDevice_.GetCurrentOutputDeviceType(); - streamCollector_.GetRendererDeviceInfo(sessionId, deviceInfo); - - AudioStreamType streamType = streamCollector_.GetStreamType(sessionId); - if (!CheckStreamOffloadMode(sessionId, streamType)) { - return; - } - - Trace trace("AudioOffloadStream::OffloadStreamSetCheck:Getting offload stream:" + std::to_string(sessionId)); - auto CallingUid = IPCSkeleton::GetCallingUid(); - AUDIO_INFO_LOG("sessionId[%{public}d] CallingUid[%{public}d] StreamType[%{public}d] " - "Getting offload stream", sessionId, CallingUid, streamType); std::lock_guard lock(offloadMutex_); - if (!offloadSessionID_.has_value()) { - offloadSessionID_ = sessionId; - audioPolicyManager_.SetOffloadSessionId(sessionId); - - AUDIO_DEBUG_LOG("sessionId[%{public}d] try get offload stream", sessionId); - if (MoveToNewPipeInner(sessionId, PIPE_TYPE_OFFLOAD) != SUCCESS) { - AUDIO_ERR_LOG("sessionId[%{public}d] CallingUid[%{public}d] StreamType[%{public}d] " - "failed to offload stream", sessionId, CallingUid, streamType); - offloadSessionID_.reset(); - audioPolicyManager_.ResetOffloadSessionId(); - return; - } - SetOffloadMode(); - } else { - if (sessionId == *(offloadSessionID_)) { - AUDIO_DEBUG_LOG("sessionId[%{public}d] is already get offload stream", sessionId); - } else { - AUDIO_DEBUG_LOG("sessionId[%{public}d] no get offload, current offload sessionId[%{public}d]", - sessionId, *(offloadSessionID_)); + for (auto &iter : offloadSessionIdMap_) { + if (iter.second == sessionId) { + // Find target sessionId, means offload status is already been set or the stream is moved from + // one offload pipe to another offload pipe, map record should be reset. + iter.second = NO_OFFLOAD_STREAM_SESSIONID; } } - return; + AUDIO_INFO_LOG("Set offload session: %{public}u", sessionId); + offloadSessionIdMap_[offloadAdapter] = sessionId; + SetOffloadStatusInternal(sessionId); } -bool AudioOffloadStream::CheckStreamOffloadMode(int64_t activateSessionId, AudioStreamType streamType) +void AudioOffloadStream::UnsetOffloadStatus(uint32_t sessionId) { - if (!GetOffloadAvailableFromXml()) { - AUDIO_INFO_LOG("Offload not available, skipped for set"); - return false; - } - - if (!audioActiveDevice_.CheckActiveOutputDeviceSupportOffload()) { - AUDIO_PRERELEASE_LOGI("Offload not available on current output device, skipped"); - return false; - } - - if ((streamType != STREAM_MUSIC) && (streamType != STREAM_SPEECH)) { - AUDIO_DEBUG_LOG("StreamType not allowed get offload mode, Skipped"); - return false; - } - - AudioPipeType pipeType; - streamCollector_.GetPipeType(activateSessionId, pipeType); - if (pipeType == PIPE_TYPE_DIRECT_MUSIC) { - AUDIO_INFO_LOG("stream is direct, Skipped"); - return false; - } - - int32_t channelCount = streamCollector_.GetChannelCount(activateSessionId); - if ((channelCount != AudioChannel::MONO) && (channelCount != AudioChannel::STEREO)) { - AUDIO_DEBUG_LOG("ChannelNum not allowed get offload mode, Skipped"); - return false; - } - - int32_t offloadUID = streamCollector_.GetUid(activateSessionId); - if (offloadUID == -1) { - AUDIO_DEBUG_LOG("offloadUID not valid, Skipped"); - return false; - } - if (offloadUID == UID_AUDIO) { - AUDIO_DEBUG_LOG("Skip anco_audio out of offload mode"); - return false; - } + std::lock_guard lock(offloadMutex_); - if (CheckSpatializationAndEffectState()) { - AUDIO_INFO_LOG("spatialization effect in arm, Skipped"); - return false; + for (auto &iter : offloadSessionIdMap_) { + if (iter.second == sessionId) { + iter.second = NO_OFFLOAD_STREAM_SESSIONID; + UnsetOffloadStatusInternal(sessionId); + } } - return true; } -AudioModuleInfo AudioOffloadStream::ConstructMchAudioModuleInfo(DeviceType deviceType) +void AudioOffloadStream::UpdateOffloadStatusFromUpdateTracker(uint32_t sessionId, RendererState state) { - AudioModuleInfo audioModuleInfo = {}; - audioModuleInfo.lib = "libmodule-hdi-sink.z.so"; - audioModuleInfo.format = "s32le"; // 32bit little endian - audioModuleInfo.fixedLatency = "1"; // here we need to set latency fixed for a fixed buffer size. - - // used as "sink_name" in hdi_sink.c, hope we could use name to find target sink. - audioModuleInfo.name = MCH_PRIMARY_SPEAKER; - - std::stringstream typeValue; - typeValue << static_cast(deviceType); - audioModuleInfo.deviceType = typeValue.str(); - - bool isDefaultAdapterEnable = AudioPolicyConfigManager::GetInstance().GetDefaultAdapterEnable(); - audioModuleInfo.defaultAdapterEnable = isDefaultAdapterEnable ? "1" : "0"; - audioModuleInfo.adapterName = "primary"; - audioModuleInfo.className = "multichannel"; // used in renderer_sink_adapter.c - audioModuleInfo.fileName = "mch_dump_file"; - - audioModuleInfo.channels = "6"; - audioModuleInfo.rate = "48000"; - audioModuleInfo.bufferSize = "7680"; - - return audioModuleInfo; -} - -bool AudioOffloadStream::CheckSpatializationAndEffectState() -{ - AudioSpatializationState spatialState = - AudioSpatializationService::GetAudioSpatializationService().GetSpatializationState(); - bool effectOffloadFlag = AudioServerProxy::GetInstance().GetEffectOffloadEnabledProxy(); - return spatialState.spatializationEnabled && !effectOffloadFlag; -} - -int32_t AudioOffloadStream::LoadMchModule() -{ - AUDIO_INFO_LOG("load multichannel mode"); - DeviceType deviceType = DEVICE_TYPE_SPEAKER; - AudioModuleInfo moduleInfo = ConstructMchAudioModuleInfo(deviceType); - audioIOHandleMap_.OpenPortAndInsertIOHandle(moduleInfo.name, moduleInfo); - return SUCCESS; -} - -int32_t AudioOffloadStream::UnloadMchModule() -{ - AUDIO_INFO_LOG("unload multichannel module"); - return audioIOHandleMap_.ClosePortAndEraseIOHandle(MCH_PRIMARY_SPEAKER); -} - -int32_t AudioOffloadStream::MoveToNewPipeInner(uint32_t sessionId, AudioPipeType pipeType) -{ - AudioPipeType oldPipeType; - streamCollector_.GetPipeType(sessionId, oldPipeType); - Trace tracePipe("AudioOffloadStream::MoveToNewPipeInner:sessionId:" + std::to_string(sessionId) + - " from " + std::to_string(oldPipeType) + " to " + std::to_string(pipeType)); - if (oldPipeType == pipeType) { - AUDIO_ERR_LOG("the same type [%{public}d],no need to move", pipeType); - return SUCCESS; - } - Trace trace("AudioOffloadStream::MoveToNewPipeInner"); - AUDIO_INFO_LOG("start move stream %{public}d from %{public}d into new pipe %{public}d", sessionId, - oldPipeType, pipeType); - int32_t ret = SwitchToNewPipe(sessionId, pipeType); - - return ret; -} + std::lock_guard lock(offloadMutex_); -int32_t AudioOffloadStream::SwitchToNewPipe(const uint32_t sessionId, const AudioPipeType pipeType) -{ - int32_t ret = ERROR; - std::string portName = PORT_NONE; - AudioStreamType streamType = streamCollector_.GetStreamType(sessionId); - DeviceType deviceType = audioActiveDevice_.GetCurrentOutputDeviceType(); - switch (pipeType) { - case PIPE_TYPE_OFFLOAD: { - if (!CheckStreamOffloadMode(sessionId, streamType)) { - return ERROR; + for (auto &iter : offloadSessionIdMap_) { + if (iter.second == sessionId) { + if (state == RENDERER_RUNNING) { + AudioServerProxy::GetInstance().SetOffloadModeProxy( + sessionId, static_cast(currentPowerState_), false); } - if (LoadOffloadModule() != SUCCESS) { - return ERROR; - } - portName = AudioPolicyUtils::GetInstance().GetSinkPortName(deviceType, pipeType); - audioIOHandleMap_.MuteSinkPort(portName, SELECT_PIPE_TYPE_OFFLOAD_MUTE_US, true, false); - ret = MoveToOutputDevice(sessionId, portName); - break; - } - case PIPE_TYPE_MULTICHANNEL: { - if (!CheckStreamMultichannelMode(sessionId)) { - return ERROR; - } - if (audioIOHandleMap_.CheckIOHandleExist(MCH_PRIMARY_SPEAKER) == false) { - // load moudle and move into new sink - LoadMchModule(); - } - portName = AudioPolicyUtils::GetInstance().GetSinkPortName(deviceType, pipeType); - ret = MoveToOutputDevice(sessionId, portName); - break; - } - case PIPE_TYPE_NORMAL_OUT: { - portName = AudioPolicyUtils::GetInstance().GetSinkPortName(deviceType, pipeType); - ret = MoveToOutputDevice(sessionId, portName); - break; } - default: - AUDIO_WARNING_LOG("not supported for pipe type %{public}d", pipeType); - break; } - if (ret == SUCCESS) { - streamCollector_.UpdateRendererPipeInfo(sessionId, pipeType); - } - return ret; -} - -void AudioOffloadStream::ResetOffloadMode(int32_t sessionId) -{ } -void AudioOffloadStream::OffloadStreamReleaseCheck(uint32_t sessionId) +void AudioOffloadStream::HandlePowerStateChanged(PowerMgr::PowerState state) { - if (!GetOffloadAvailableFromXml()) { - AUDIO_INFO_LOG("Offload not available, skipped for release"); + if (currentPowerState_ == state) { return; } + currentPowerState_ = state; std::lock_guard lock(offloadMutex_); - - if (((*offloadSessionID_) == sessionId) && offloadSessionID_.has_value()) { - AUDIO_DEBUG_LOG("Doing unset offload mode!"); - AudioServerProxy::GetInstance().UnsetOffloadModeProxy(*offloadSessionID_); - AudioPipeType normalPipe = PIPE_TYPE_NORMAL_OUT; - MoveToNewPipe(sessionId, normalPipe); - streamCollector_.UpdateRendererPipeInfo(sessionId, normalPipe); - DynamicUnloadOffloadModule(); - offloadSessionID_.reset(); - audioPolicyManager_.ResetOffloadSessionId(); - AUDIO_DEBUG_LOG("sessionId[%{public}d] release offload stream", sessionId); - } else { - if (offloadSessionID_.has_value()) { - AUDIO_DEBUG_LOG("sessionId[%{public}d] stopping stream not get offload, current offload [%{public}d]", - sessionId, *offloadSessionID_); - } else { - AUDIO_DEBUG_LOG("sessionId[%{public}d] stopping stream not get offload, current offload stream is None", - sessionId); + for (auto &iter : offloadSessionIdMap_) { + if (iter.second != NO_OFFLOAD_STREAM_SESSIONID) { + // Only update offload power state, other actions already done before + AudioServerProxy::GetInstance().SetOffloadModeProxy( + iter.second, static_cast(currentPowerState_), false); } } - return; -} - -int32_t AudioOffloadStream::MoveToNewPipe(uint32_t sessionId, AudioPipeType pipeType) -{ - // Check if the stream exists - int32_t defaultUid = -1; - if (defaultUid == streamCollector_.GetUid(sessionId)) { - AUDIO_ERR_LOG("The audio stream information [%{public}d] is illegal", sessionId); - return ERROR; - } - // move the stream to new pipe - return MoveToNewPipeInner(sessionId, pipeType); } -AudioModuleInfo AudioOffloadStream::ConstructOffloadAudioModuleInfo(DeviceType deviceType) +// must be called with offloadMutex_ lock +void AudioOffloadStream::SetOffloadStatusInternal(uint32_t sessionId) { - AudioModuleInfo audioModuleInfo = {}; - audioModuleInfo.lib = "libmodule-hdi-sink.z.so"; - audioModuleInfo.format = "s32le"; // 32bit little endian - audioModuleInfo.fixedLatency = "1"; // here we need to set latency fixed for a fixed buffer size. + AUDIO_INFO_LOG("Set offload enable for stream: %{public}u", sessionId); - // used as "sink_name" in hdi_sink.c, hope we could use name to find target sink. - audioModuleInfo.name = OFFLOAD_PRIMARY_SPEAKER; - - std::stringstream typeValue; - typeValue << static_cast(deviceType); - audioModuleInfo.deviceType = typeValue.str(); - - audioModuleInfo.adapterName = "primary"; - audioModuleInfo.className = "offload"; // used in renderer_sink_adapter.c - audioModuleInfo.fileName = "offload_dump_file"; - audioModuleInfo.offloadEnable = "1"; - - audioModuleInfo.channels = "2"; - audioModuleInfo.rate = "48000"; - audioModuleInfo.bufferSize = "7680"; - - return audioModuleInfo; -} - -int32_t AudioOffloadStream::LoadOffloadModule() -{ - AUDIO_INFO_LOG("load offload mode"); - std::unique_lock lock(offloadCloseMutex_); - isOffloadOpened_.store(true); - offloadCloseCondition_.notify_all(); - { - std::lock_guard lk(offloadOpenMutex_); - if (audioIOHandleMap_.CheckIOHandleExist(OFFLOAD_PRIMARY_SPEAKER)) { - AUDIO_INFO_LOG("offload is open"); - return SUCCESS; - } - - DeviceType deviceType = DEVICE_TYPE_SPEAKER; - AudioModuleInfo moduleInfo = ConstructOffloadAudioModuleInfo(deviceType); - return audioIOHandleMap_.OpenPortAndInsertIOHandle(moduleInfo.name, moduleInfo); - } - return SUCCESS; + // Offload stream need: + // 1) Set offload enabled and current power state to renderer stream in audioservice + // 2) Set offload stream sessionId to volume module + // 3) Update pipe type in stream collector + audioPolicyManager_.SetOffloadSessionId(sessionId); + AudioServerProxy::GetInstance().SetOffloadModeProxy( + sessionId, static_cast(currentPowerState_), false); + streamCollector_.UpdateRendererPipeInfo(sessionId, PIPE_TYPE_OFFLOAD); } -int32_t AudioOffloadStream::UnloadOffloadModule() +// must be called with offloadMutex_ lock +void AudioOffloadStream::UnsetOffloadStatusInternal(uint32_t sessionId) { - AUDIO_INFO_LOG("unload offload module"); - std::unique_lock lock(offloadCloseMutex_); - // Try to wait 3 seconds before unloading the module, because the audio driver takes some time to process - // the shutdown process.. - offloadCloseCondition_.wait_for(lock, std::chrono::seconds(WAIT_OFFLOAD_CLOSE_TIME_S), - [this] () { return isOffloadOpened_.load(); }); - { - std::lock_guard lk(offloadOpenMutex_); - if (isOffloadOpened_.load()) { - AUDIO_INFO_LOG("offload restart"); - return ERROR; - } - audioIOHandleMap_.ClosePortAndEraseIOHandle(OFFLOAD_PRIMARY_SPEAKER); - } - return SUCCESS; -} - + AUDIO_INFO_LOG("Unset offload enable for stream: %{public}u", sessionId); -int32_t AudioOffloadStream::DynamicUnloadOffloadModule() -{ - if (isOffloadOpened_.load()) { - isOffloadOpened_.store(false); - auto unloadFirOffloadThrd = [this] { this->UnloadOffloadModule(); }; - std::thread unloadOffloadThrd(unloadFirOffloadThrd); - unloadOffloadThrd.detach(); - } - return SUCCESS; + AudioServerProxy::GetInstance().UnsetOffloadModeProxy(sessionId); + audioPolicyManager_.ResetOffloadSessionId(); + streamCollector_.UpdateRendererPipeInfo(sessionId, PIPE_TYPE_NORMAL_OUT); } -void AudioOffloadStream::RemoteOffloadStreamRelease(uint32_t sessionId) +void AudioOffloadStream::Dump(std::string &dumpString) { std::lock_guard lock(offloadMutex_); - if (offloadSessionID_.has_value() && ((*offloadSessionID_) == sessionId)) { - AUDIO_DEBUG_LOG("Doing unset offload mode!"); - AudioServerProxy::GetInstance().UnsetOffloadModeProxy(*offloadSessionID_); - AudioPipeType normalPipe = PIPE_TYPE_UNKNOWN; - MoveToNewPipe(sessionId, normalPipe); - streamCollector_.UpdateRendererPipeInfo(sessionId, normalPipe); - DynamicUnloadOffloadModule(); - offloadSessionID_.reset(); - audioPolicyManager_.ResetOffloadSessionId(); - AUDIO_DEBUG_LOG("sessionId[%{public}d] release offload stream", sessionId); - } -} - -int32_t AudioOffloadStream::MoveToOutputDevice(uint32_t sessionId, std::string portName) -{ - std::vector sinkInputs; - audioPolicyManager_.GetAllSinkInputs(sinkInputs); - std::vector sinkInputIds = FilterSinkInputs(sessionId, sinkInputs); - - if (portName == BLUETOOTH_SPEAKER) { - std::string activePort = BLUETOOTH_SPEAKER; - audioPolicyManager_.SuspendAudioDevice(activePort, false); - } - AUDIO_INFO_LOG("move for session [%{public}d], portName %{public}s", sessionId, portName.c_str()); - // start move. - uint32_t sinkId = -1; // invalid sink id, use sink name instead. - for (size_t i = 0; i < sinkInputIds.size(); i++) { - int32_t ret = audioPolicyManager_.MoveSinkInputByIndexOrName(sinkInputIds[i].paStreamId, sinkId, portName); - CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, - "move [%{public}d] to local failed", sinkInputIds[i].streamId); - audioRouteMap_.AddRouteMapInfo(sinkInputIds[i].uid, LOCAL_NETWORK_ID, sinkInputIds[i].pid); - } - return SUCCESS; -} - -bool AudioOffloadStream::CheckStreamMultichannelMode(const int64_t activateSessionId) -{ - if (audioActiveDevice_.GetCurrentOutputDeviceNetworkId() != LOCAL_NETWORK_ID || - audioActiveDevice_.GetCurrentOutputDeviceType() == DEVICE_TYPE_REMOTE_CAST) { - return false; - } - - // Multi-channel mode only when the number of channels is greater than 2. - int32_t channelCount = streamCollector_.GetChannelCount(activateSessionId); - if (channelCount < AudioChannel::CHANNEL_3) { - AUDIO_DEBUG_LOG("ChannelNum not allowed get multichannel mode, Skipped"); - return false; - } - - // The multi-channel algorithm needs to be supported in the DSP - return AudioServerProxy::GetInstance().GetEffectOffloadEnabledProxy(); + dumpString += ("\n"); + dumpString += ("OffloadSessionIdPrimary: " + std::to_string(offloadSessionIdMap_[OFFLOAD_IN_PRIMARY]) + "\n"); + dumpString += ("OffloadSessionIdRemote: " + std::to_string(offloadSessionIdMap_[OFFLOAD_IN_REMOTE]) + "\n"); } std::vector AudioOffloadStream::FilterSinkInputs(int32_t sessionId, std::vector sinkInputs) @@ -478,73 +130,15 @@ std::vector AudioOffloadStream::FilterSinkInputs(int32_t sessionId, s std::vector targetSinkInputs = {}; for (size_t i = 0; i < sinkInputs.size(); i++) { - CHECK_AND_CONTINUE_LOG(sinkInputs[i].uid != dAudioClientUid, + CHECK_AND_CONTINUE_LOG(sinkInputs[i].uid != UID_DAUDIO, "Find sink-input with daudio[%{public}d]", sinkInputs[i].pid); CHECK_AND_CONTINUE_LOG(sinkInputs[i].streamType != STREAM_DEFAULT, "Sink-input[%{public}zu] of effect sink, don't move", i); - AUDIO_DEBUG_LOG("sinkinput[%{public}zu]:%{public}s", i, PrintSinkInput(sinkInputs[i]).c_str()); if (sessionId == sinkInputs[i].streamId) { targetSinkInputs.push_back(sinkInputs[i]); } } return targetSinkInputs; } - -void AudioOffloadStream::ResetOffloadModeOnSpatializationChanged(std::vector &allSessions) -{ - AudioSpatializationState spatialState = - AudioSpatializationService::GetAudioSpatializationService().GetSpatializationState(); - bool effectOffloadFlag = AudioServerProxy::GetInstance().GetEffectOffloadEnabledProxy(); - AUDIO_INFO_LOG("spatialization: %{public}d, headTracking: %{public}d, effectOffloadFlag: %{public}d", - spatialState.spatializationEnabled, spatialState.headTrackingEnabled, effectOffloadFlag); - if (spatialState.spatializationEnabled) { - if (effectOffloadFlag) { - for (auto it = allSessions.begin(); it != allSessions.end(); it++) { - OffloadStreamSetCheck(*it); - } - } else { - OffloadStreamReleaseCheck(*offloadSessionID_); - } - } -} - -void AudioOffloadStream::ResetOffloadStatus(uint32_t sessionId) -{ - AUDIO_INFO_LOG("Reset offload state for session: %{public}u", sessionId); - if (offloadSessionID_.has_value() && ((*offloadSessionID_) == sessionId)) { - AUDIO_INFO_LOG("Current offload session: %{public}u", (*offloadSessionID_)); - std::lock_guard lock(offloadMutex_); - AudioServerProxy::GetInstance().UnsetOffloadModeProxy(sessionId); - AudioPipeType normalPipe = PIPE_TYPE_NORMAL_OUT; - streamCollector_.UpdateRendererPipeInfo(sessionId, normalPipe); - offloadSessionID_.reset(); - audioPolicyManager_.ResetOffloadSessionId(); - } -} - -void AudioOffloadStream::SetOffloadStatus(uint32_t sessionId) -{ - AudioStreamType streamType = streamCollector_.GetStreamType(sessionId); - auto callingUid = IPCSkeleton::GetCallingUid(); - AUDIO_INFO_LOG("sessionId[%{public}d] callingUid[%{public}d] StreamType[%{public}d] " - "Getting offload stream", sessionId, callingUid, streamType); - std::lock_guard lock(offloadMutex_); - - if (!offloadSessionID_.has_value()) { - offloadSessionID_ = sessionId; - audioPolicyManager_.SetOffloadSessionId(sessionId); - AUDIO_DEBUG_LOG("sessionId[%{public}d] try get offload stream", sessionId); - SetOffloadMode(); - AudioPipeType offloadPipe = PIPE_TYPE_OFFLOAD; - streamCollector_.UpdateRendererPipeInfo(sessionId, offloadPipe); - } else { - if (sessionId == *(offloadSessionID_)) { - AUDIO_DEBUG_LOG("sessionId[%{public}d] is already get offload stream", sessionId); - } else { - AUDIO_DEBUG_LOG("sessionId[%{public}d] no get offload, current offload sessionId[%{public}d]", - sessionId, *(offloadSessionID_)); - } - } -} -} -} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/domain/pipe/src/audio_pipe_manager.cpp b/services/audio_policy/server/domain/pipe/src/audio_pipe_manager.cpp index 3284aff199c90d813f511eb07c34b3b76a38187a..1d20e69d20108bc7767fba5a0720cb928798c2f0 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_pipe_manager.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_pipe_manager.cpp @@ -139,12 +139,14 @@ const std::vector> AudioPipeManager::GetPipeList( return curPipeList_; } -std::vector> AudioPipeManager::GetUnusedPipe() +std::vector> AudioPipeManager::GetUnusedPipe(DeviceType curOutputDeviceType) { std::unique_lock pLock(pipeListLock_); std::vector> newList; for (auto pipe : curPipeList_) { - if (pipe->streamDescriptors_.empty() && IsSpecialPipe(pipe->routeFlag_)) { + CHECK_AND_CONTINUE_LOG(pipe != nullptr, "pipe is nullptr"); + if (pipe->streamDescriptors_.empty() && (IsSpecialPipe(pipe->routeFlag_) || + (pipe->adapterName_ == A2DP_CLASS && curOutputDeviceType == DEVICE_TYPE_BLUETOOTH_A2DP))) { newList.push_back(pipe); } } @@ -174,7 +176,8 @@ bool AudioPipeManager::IsSpecialPipe(uint32_t routeFlag) AUDIO_INFO_LOG("Flag %{public}d", routeFlag); if ((routeFlag & AUDIO_OUTPUT_FLAG_FAST) || (routeFlag & AUDIO_INPUT_FLAG_FAST) || - (routeFlag & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) { + (routeFlag & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) || + (routeFlag & AUDIO_INPUT_FLAG_AI)) { return true; } return false; @@ -393,6 +396,8 @@ void AudioPipeManager::Dump(std::string &dumpString) pipe->Dump(dumpString); } } + + dumpString += "PipeManager dump end\n"; } bool AudioPipeManager::IsModemCommunicationIdExist() @@ -551,5 +556,26 @@ std::vector> AudioPipeManager::GetAllCapt } return streamDescs; } + +std::shared_ptr AudioPipeManager::FindPipeBySessionId( + const std::vector> &pipeList, uint32_t sessionId) +{ + for (const auto &pipe : pipeList) { + if (pipe == nullptr) { + continue; + } + + for (const auto &stream : pipe->streamDescriptors_) { + if (stream == nullptr) { + continue; + } + if (stream->sessionId_ == sessionId) { + AUDIO_INFO_LOG("find pipe: %{public}s by sessionId: %{public}u", pipe->name_.c_str(), sessionId); + return pipe; + } + } + } + return std::shared_ptr(); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/domain/pipe/src/audio_pipe_selector.cpp b/services/audio_policy/server/domain/pipe/src/audio_pipe_selector.cpp index 2c624b59fa567137282c2c300f0cfca5b2e4f2be..d0ef60f3fe0ff847eb6d2ba28d314ff649578130 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_pipe_selector.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_pipe_selector.cpp @@ -76,24 +76,26 @@ std::vector> AudioPipeSelector::FetchPipeAndExecu } } + // Generate pipeInfo by configuration for incoming stream streamDesc->streamAction_ = AUDIO_STREAM_ACTION_NEW; std::shared_ptr streamPropInfo = std::make_shared(); configManager_.GetStreamPropInfo(streamDesc, streamPropInfo); - UpdataDeviceStreamInfo(streamDesc, streamPropInfo); + UpdateDeviceStreamInfo(streamDesc, streamPropInfo); std::shared_ptr pipeInfoPtr = streamPropInfo->pipeInfo_.lock(); if (pipeInfoPtr == nullptr) { AUDIO_ERR_LOG("Pipe info is null"); return selectedPipeInfoList; } + + // Find whether any existing pipe matches for (auto &pipeInfo : selectedPipeInfoList) { std::shared_ptr adapterInfoPtr = pipeInfoPtr->adapterInfo_.lock(); if (adapterInfoPtr == nullptr) { AUDIO_ERR_LOG("Adapter info is null"); continue; } - AUDIO_INFO_LOG("[Cur][XML]: {adapterName}[%{public}s][%{public}s], {routeFlag}[%{public}x][%{public}x]", - pipeInfo->adapterName_.c_str(), adapterInfoPtr->adapterName.c_str(), - pipeInfo->routeFlag_, streamDesc->routeFlag_); + AUDIO_INFO_LOG("action %{public}d adapter[%{public}s] pipeRoute[0x%{public}x] streamRoute[0x%{public}x]", + pipeInfo->GetAction(), pipeInfo->GetAdapterName().c_str(), pipeInfo->GetRoute(), streamDesc->GetRoute()); if (pipeInfo->adapterName_ == adapterInfoPtr->adapterName && pipeInfo->routeFlag_ == streamDesc->routeFlag_) { @@ -105,16 +107,19 @@ std::vector> AudioPipeSelector::FetchPipeAndExecu return selectedPipeInfoList; } } + + // Need to open a new pipe for incoming stream AudioPipeInfo info = {}; ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info); info.pipeAction_ = PIPE_ACTION_NEW; selectedPipeInfoList.push_back(std::make_shared(info)); AUDIO_INFO_LOG("[PipeFetchInfo] use new Pipe %{public}s for stream %{public}u", info.ToString().c_str(), streamDesc->sessionId_); + return selectedPipeInfoList; } -void AudioPipeSelector::UpdataDeviceStreamInfo(std::shared_ptr &streamDesc, +void AudioPipeSelector::UpdateDeviceStreamInfo(std::shared_ptr &streamDesc, std::shared_ptr streamPropInfo) { if (streamDesc->newDeviceDescs_.empty() || streamPropInfo == nullptr || streamDesc->newDeviceDescs_.front() == @@ -136,17 +141,20 @@ void AudioPipeSelector::UpdataDeviceStreamInfo(std::shared_ptr> &streamDescs) { CHECK_AND_RETURN_LOG(streamDescs.size() != 0, "streamDescs is empty!"); + SortStreamDescsByStartTime(streamDescs); streamDescs[0]->routeFlag_ = GetRouteFlagByStreamDesc(streamDescs[0]); if (streamDescs.size() == 1) { return; } - SortStreamDescsByStartTime(streamDescs); + // Do not need to move stream, because stream actions are all decided in DecidePipesAndStreamAction(), + // not in ProcessConcurrency(). + std::vector> streamsMoveToNormal; for (size_t cmpStreamIdx = 1; cmpStreamIdx < streamDescs.size(); ++cmpStreamIdx) { streamDescs[cmpStreamIdx]->routeFlag_ = GetRouteFlagByStreamDesc(streamDescs[cmpStreamIdx]); // calculate concurrency in time order for (size_t curStreamDescIdx = 0; curStreamDescIdx < cmpStreamIdx; ++curStreamDescIdx) { - ProcessConcurrency(streamDescs[curStreamDescIdx], streamDescs[cmpStreamIdx]); + ProcessConcurrency(streamDescs[curStreamDescIdx], streamDescs[cmpStreamIdx], streamsMoveToNormal); } } } @@ -193,11 +201,12 @@ void AudioPipeSelector::DecidePipesAndStreamAction(std::vectorsessionId_); continue; } - streamDesc->streamAction_ = JudgeStreamAction(newPipeInfo, streamDescToOldPipeInfo[streamDesc->sessionId_]); + streamDesc->SetAction(JudgeStreamAction(newPipeInfo, streamDescToOldPipeInfo[streamDesc->GetSessionId()])); + streamDesc->SetOldRoute(streamDescToOldPipeInfo[streamDesc->GetSessionId()]->GetRoute()); AUDIO_INFO_LOG(" |--[PipeFetchInfo] SessionId %{public}d, PipeRouteFlag %{public}d --> %{public}d, " - "streamAction %{public}d", streamDesc->sessionId_, - streamDescToOldPipeInfo[streamDesc->sessionId_]->routeFlag_, - newPipeInfo->routeFlag_, streamDesc->streamAction_); + "streamAction %{public}d", streamDesc->GetSessionId(), + streamDescToOldPipeInfo[streamDesc->GetSessionId()]->GetRoute(), + newPipeInfo->GetRoute(), streamDesc->GetAction()); } if (newPipeInfo->streamDescriptors_.size() == 0) { AUDIO_INFO_LOG(" |--[PipeFetchInfo] Empty"); @@ -273,14 +282,20 @@ void AudioPipeSelector::ScanPipeListForStreamDesc(std::vectorrouteFlag_ = GetRouteFlagByStreamDesc(streamDesc); AUDIO_INFO_LOG("Route flag: %{public}u", streamDesc->routeFlag_); + std::vector> streamsMoveToNormal; for (auto &pipeInfo : pipeInfoList) { bool isUpdate = false; for (auto &streamDescInPipe : pipeInfo->streamDescriptors_) { - isUpdate = ProcessConcurrency(streamDescInPipe, streamDesc); + isUpdate = ProcessConcurrency(streamDescInPipe, streamDesc, streamsMoveToNormal); AUDIO_INFO_LOG("isUpdate: %{public}d, action: %{public}d", isUpdate, streamDescInPipe->streamAction_); } - pipeInfo->pipeAction_ = isUpdate ? PIPE_ACTION_UPDATE : pipeInfo->pipeAction_; + if (isUpdate && pipeInfo->GetAction() != PIPE_ACTION_NEW) { + pipeInfo->SetAction(PIPE_ACTION_UPDATE); + } } + // Move concede existing streams to its corresponding normal pipe + MoveStreamsToNormalPipes(streamsMoveToNormal, pipeInfoList); + AUDIO_INFO_LOG("Route flag after concurrency: %{public}u", streamDesc->routeFlag_); } @@ -313,19 +328,22 @@ AudioPipeType AudioPipeSelector::GetPipeType(uint32_t flag, AudioMode audioMode) } else { return PIPE_TYPE_LOWLATENCY_IN; } + } else if (flag & AUDIO_INPUT_FLAG_AI) { + return PIPE_TYPE_NORMAL_IN_AI; } else { return PIPE_TYPE_NORMAL_IN; } } } -void AudioPipeSelector::IncomingConcurrency(std::shared_ptr stream, - std::shared_ptr cmpStream) +void AudioPipeSelector::CheckAndHandleIncomingConcurrency(std::shared_ptr existingStream, + std::shared_ptr incomingStream) { - // normal, mmap or voipmmap can't concurrency, if concede existing must concede incoming - if (cmpStream->audioMode_ == AUDIO_MODE_RECORD && stream->audioMode_ == AUDIO_MODE_RECORD) { - cmpStream->routeFlag_ = AUDIO_INPUT_FLAG_NORMAL; - AUDIO_INFO_LOG("capture in: %{public}u old: %{public}u", cmpStream->sessionId_, stream->sessionId_); + // Normal, fast or voip-fast can not run concurrently, both stream need to be conceded + if (incomingStream->IsRecording() && existingStream->IsRecording()) { + AUDIO_INFO_LOG("capture in: %{public}u old: %{public}u", + incomingStream->sessionId_, existingStream->sessionId_); + incomingStream->ResetToNormalRoute(false); } } @@ -357,34 +375,45 @@ bool AudioPipeSelector::IsSameAdapter(std::shared_ptr str return false; } -bool AudioPipeSelector::ProcessConcurrency(std::shared_ptr stream, - std::shared_ptr cmpStream) +bool AudioPipeSelector::ProcessConcurrency(std::shared_ptr existingStream, + std::shared_ptr incomingStream, + std::vector> &streamsToMove) { + ConcurrencyAction action = action = AudioStreamCollector::GetAudioStreamCollector().GetConcurrencyAction( + GetPipeType(existingStream->routeFlag_, existingStream->audioMode_), + GetPipeType(incomingStream->routeFlag_, incomingStream->audioMode_)); + action = IsSameAdapter(existingStream, incomingStream) ? action : PLAY_BOTH; + // No running offload can not concede incoming special pipe + if (action == CONCEDE_INCOMING && existingStream->IsNoRunningOffload()) { + action = CONCEDE_EXISTING; + } + AUDIO_INFO_LOG("Action: %{public}u " + "existingStream id: %{public}u, routeFlag: %{public}u; " + "incomingStream id: %{public}u, routeFlag: %{public}u", + action, + existingStream->GetSessionId(), existingStream->GetRoute(), + incomingStream->GetSessionId(), incomingStream->GetRoute()); + bool isUpdate = false; - std::map, ConcurrencyAction> ruleMap = - AudioStreamCollector::GetAudioStreamCollector().GetConcurrencyMap(); - ConcurrencyAction action = ruleMap[std::make_pair(GetPipeType(stream->routeFlag_, stream->audioMode_), - GetPipeType(cmpStream->routeFlag_, cmpStream->audioMode_))]; - action = IsSameAdapter(stream, cmpStream) ? action : PLAY_BOTH; - AUDIO_INFO_LOG("Action: %{public}u %{public}u -- %{public}u", action, stream->sessionId_, cmpStream->sessionId_); - uint32_t newFlag; switch (action) { case PLAY_BOTH: - stream->streamAction_ = AUDIO_STREAM_ACTION_DEFAULT; break; case CONCEDE_INCOMING: - stream->streamAction_ = AUDIO_STREAM_ACTION_DEFAULT; - cmpStream->routeFlag_ = cmpStream->audioMode_ == AUDIO_MODE_PLAYBACK ? - AUDIO_OUTPUT_FLAG_NORMAL : AUDIO_INPUT_FLAG_NORMAL; + incomingStream->ResetToNormalRoute(false); break; case CONCEDE_EXISTING: - // if concede existing, maybe need concede incomming - IncomingConcurrency(stream, cmpStream); + // If action is concede existing, maybe also need to concede incoming + CheckAndHandleIncomingConcurrency(existingStream, incomingStream); isUpdate = true; - newFlag = stream->audioMode_ == AUDIO_MODE_PLAYBACK ? - AUDIO_OUTPUT_FLAG_NORMAL : AUDIO_INPUT_FLAG_NORMAL; - stream->streamAction_ = AUDIO_STREAM_ACTION_RECREATE; - stream->routeFlag_ = newFlag; + if (existingStream->IsUseMoveToConcedeType()) { + existingStream->SetAction(AUDIO_STREAM_ACTION_MOVE); + // Do not move stream here, because it is still in for-each loop + streamsToMove.push_back(existingStream); + } else { + existingStream->SetAction(AUDIO_STREAM_ACTION_RECREATE); + } + // Set stream route flag to normal here so it will not affect later streams in loop + existingStream->ResetToNormalRoute(true); break; default: break; @@ -521,5 +550,55 @@ void AudioPipeSelector::SortStreamDescsByStartTime(std::vectorcreateTimeStamp_ < streamDesc2->createTimeStamp_; }); } + +void AudioPipeSelector::MoveStreamsToNormalPipes( + std::vector> &streamsToMove, + std::vector> &pipeInfoList) +{ + std::map, std::string> streamToAdapter; + RemoveTargetStreams(streamsToMove, pipeInfoList, streamToAdapter); + + // Put each stream to its according normal pipe + for (auto &stream : streamsToMove) { + for (auto &pipe : pipeInfoList) { + if (pipe->IsRouteNormal() && pipe->IsSameAdapter(streamToAdapter[stream])) { + AddStreamToPipeAndUpdateAction(stream, pipe); + break; + } + } + } +} + +void AudioPipeSelector::AddStreamToPipeAndUpdateAction( + std::shared_ptr &streamToAdd, std::shared_ptr &pipe) +{ + AUDIO_INFO_LOG("Put stream %{public}u to pipe %{public}s", + streamToAdd->GetSessionId(), pipe->GetName().c_str()); + pipe->AddStream(streamToAdd); + // When fetching, pipe action may already be PIPE_ACTION_NEW before, + // do not change it to PIPE_ACTION_UPDATE. + if (pipe->GetAction() != PIPE_ACTION_NEW) { + pipe->SetAction(PIPE_ACTION_UPDATE); + } +} + +void AudioPipeSelector::RemoveTargetStreams( + std::vector> streamsToMove, + std::vector> &pipeInfoList, + std::map, std::string> &streamToAdapter) +{ + // Remove streams from old pipes and record old pipe adapter which is used to find + // normal pipe in the same adapter. + for (auto &stream : streamsToMove) { + for (auto &pipe : pipeInfoList) { + if (pipe->ContainStream(stream->GetSessionId())) { + streamToAdapter[stream] = pipe->GetAdapterName(); + pipe->RemoveStream(stream->GetSessionId()); + // Should be only one matching pipe + break; + } + } + } +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/src/audio_policy_config_manager.cpp b/services/audio_policy/server/domain/pipe/src/audio_policy_config_manager.cpp index f2a915b751427455db2673f0844e3270761fa19c..027996f8ad0b39dd2bc705103d72997f762cc0a7 100644 --- a/services/audio_policy/server/domain/pipe/src/audio_policy_config_manager.cpp +++ b/services/audio_policy/server/domain/pipe/src/audio_policy_config_manager.cpp @@ -18,6 +18,7 @@ #include "audio_policy_config_manager.h" #include "audio_policy_config_parser.h" +#include "audio_source_strategy_parser.h" #include "audio_policy_utils.h" #include "audio_policy_service.h" #include "audio_ec_manager.h" @@ -65,6 +66,15 @@ bool AudioPolicyConfigManager::Init(bool isRefresh) AUDIO_ERR_LOG("Audio Policy Config Load Configuration failed"); return ret; } + + std::unique_ptr audioSourceStrategyParser = make_unique(); + CHECK_AND_RETURN_RET_LOG(audioSourceStrategyParser != nullptr, false, "AudioSourceStrategyParser create failed"); + ret = audioSourceStrategyParser->LoadConfig(); + if (ret == false) { + AudioPolicyUtils::GetInstance().WriteServiceStartupError("Audio SourceStrategy Load Configuration failed"); + AUDIO_ERR_LOG("Audio SourceStrategy Load Configuration failed"); + } + xmlHasLoaded_ = true; return ret; } @@ -630,7 +640,9 @@ void AudioPolicyConfigManager::GetStreamPropInfo(std::shared_ptrsupportPipeMap_.find(desc->routeFlag_); - CHECK_AND_RETURN_LOG(pipeIt != deviceInfo->supportPipeMap_.end(), "Find pipeInfo failed;none streamProp"); + CHECK_AND_RETURN_LOG(pipeIt != deviceInfo->supportPipeMap_.end(), + "Find no support pipe for stream %{public}u, route %{public}u", + desc->GetSessionId(), desc->GetRoute()); AudioStreamInfo temp = desc->streamInfo_; UpdateBasicStreamInfo(desc, pipeIt->second, temp); diff --git a/services/audio_policy/server/domain/pipe/test/BUILD.gn b/services/audio_policy/server/domain/pipe/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..807e1d9870d7f3fd1081e84e57bfeff649e9acc8 --- /dev/null +++ b/services/audio_policy/server/domain/pipe/test/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../../accessibility.gni") +import("../../../../../../appgallery.gni") +import("../../../../../../bluetooth_part.gni") +import("../../../../../../config.gni") + +audio_framework_root = "../../../../../.." +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +group("audio_policy_pipe_unittest_packages") { + testonly = true + deps = [ + ":audio_capturer_session_ext_unit_test", + ] +} + +ohos_unittest("audio_capturer_session_ext_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./unittest/audio_capturer_session_unit_test/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + cflags_cc = cflags + + external_deps = [ + "bluetooth:btframework", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "googletest:gmock", + "hilog:libhilog", + "init:libbegetutil", + "kv_store:distributeddata_inner", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + "eventhandler:libeventhandler", + ] + + sources = [ "./unittest/audio_capturer_session_unit_test/src/audio_capturer_session_ext_unit_test.cpp" ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../../../../audio_policy:audio_policy_service_static", + ] +} \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/test/unittest/BUILD.gn b/services/audio_policy/server/domain/pipe/test/unittest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..089eccd4a29773e1549269c7f2b644c15b38d337 --- /dev/null +++ b/services/audio_policy/server/domain/pipe/test/unittest/BUILD.gn @@ -0,0 +1,123 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +audio_framework_root = "../../../../../../.." +audio_policy_root = "../../../../.." +module_output_path = "audio_framework/audio_framework_policy/audio_policy/pipe" + +import("//build/ohos.gni") +import("//build/test.gni") +import("${audio_framework_root}/accessibility.gni") +import("${audio_framework_root}/appgallery.gni") +import("${audio_framework_root}/bluetooth_part.gni") +import("${audio_framework_root}/config.gni") + +group("pipe_domain_unit_test_group") { + testonly = true + deps = [ + ":audio_offload_stream_unit_test", + ":audio_a2dp_offload_manager_unit_test", + ] +} + +ohos_unittest("audio_offload_stream_unit_test") { + module_out_path = module_output_path + include_dirs = [ + ".", + ] + + cflags = [ + "-Wall", + "-Werror", + "-fno-access-control", + ] + + sanitize = { + cfi = true + cfi_cross_dso = true + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = true + } + + sources = [ "audio_offload_stream_unit_test.cpp" ] + + configs = [ "${audio_policy_root}/:audio_policy_public_config" ] + + deps = [ + "${audio_policy_root}/:audio_policy_service_static", + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + ] + + external_deps = [ + "c_utils:utils", + "data_share:datashare_consumer", + "eventhandler:libeventhandler", + "hilog:libhilog", + "kv_store:distributeddata_inner", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + ] + + defines = [] + + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } +} + +ohos_unittest("audio_a2dp_offload_manager_unit_test") { + module_out_path = module_output_path + include_dirs = [ + ".", + ] + + cflags = [ + "-Wall", + "-Werror", + "-fno-access-control", + ] + + sanitize = { + cfi = true + cfi_cross_dso = true + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = true + } + + sources = [ "audio_a2dp_offload_manager_unit_test.cpp" ] + + deps = [ + "${audio_policy_root}/:audio_policy_service_static", + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + ] + + external_deps = [ + "c_utils:utils", + "eventhandler:libeventhandler", + "googletest:gmock", + "hilog:libhilog", + "ipc:ipc_single", + ] + + defines = [] + if (bluetooth_part_enable == true) { + defines += [ "BLUETOOTH_ENABLE" ] + deps += + [ "${audio_framework_root}/frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } +} diff --git a/services/audio_policy/server/domain/pipe/test/unittest/audio_a2dp_offload_manager_unit_test.cpp b/services/audio_policy/server/domain/pipe/test/unittest/audio_a2dp_offload_manager_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cce41c5b2ae33a94843ce40a2526c073b1834ebd --- /dev/null +++ b/services/audio_policy/server/domain/pipe/test/unittest/audio_a2dp_offload_manager_unit_test.cpp @@ -0,0 +1,542 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_a2dp_offload_manager_unit_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +static const std::string TEST_DEVICE_ADDR = "00:11:22:33:44:55"; +static const int32_t TEST_SESSION_ID_BASE = 100000; +static const int32_t TEST_STREAM_1_SESSION_ID = 100001; +static const int32_t TEST_STREAM_2_SESSION_ID = 100002; +static const int32_t TEST_STREAM_3_SESSION_ID = 100003; +static std::vector TEST_SESSION_ID_VECTOR = { + TEST_STREAM_1_SESSION_ID, + TEST_STREAM_2_SESSION_ID, + TEST_STREAM_3_SESSION_ID +}; + +void AudioA2dpOffloadManagerUnitTest::SetUpTestCase(void) {} +void AudioA2dpOffloadManagerUnitTest::TearDownTestCase(void) {} + +void AudioA2dpOffloadManagerUnitTest::SetUp(void) +{ + testManager_ = std::make_shared(); +} + +void AudioA2dpOffloadManagerUnitTest::TearDown(void) +{ + testManager_ = nullptr; +} + +void AudioA2dpOffloadManagerUnitTest::MakeStreamCollectorData(uint32_t runningStreamCnt, uint32_t stopStreamCnt) +{ + if (testManager_ == nullptr) { + return; + } + + for (uint32_t i = 0; i < runningStreamCnt; ++i) { + AudioStreamChangeInfo streamInfo; + streamInfo.audioRendererChangeInfo.sessionId = i + TEST_SESSION_ID_BASE; + streamInfo.audioRendererChangeInfo.rendererState = RENDERER_RUNNING; + testManager_->streamCollector_.AddRendererStream(streamInfo); + } + + for (uint32_t i = 0; i < stopStreamCnt; ++i) { + AudioStreamChangeInfo streamInfo; + streamInfo.audioRendererChangeInfo.sessionId = i + runningStreamCnt + TEST_SESSION_ID_BASE; + streamInfo.audioRendererChangeInfo.rendererState = RENDERER_STOPPED; + testManager_->streamCollector_.AddRendererStream(streamInfo); + } +} + +/** + * @tc.name: ConnectA2dpOffload_001 + * @tc.desc: Test ConnectA2dpOffload with state already connected. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, ConnectA2dpOffload_001, TestSize.Level1) +{ + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + testManager_->ConnectA2dpOffload(TEST_DEVICE_ADDR, TEST_SESSION_ID_VECTOR); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTED); +} + +/** + * @tc.name: ConnectA2dpOffload_002 + * @tc.desc: Test ConnectA2dpOffload with state already connecting. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, ConnectA2dpOffload_002, TestSize.Level1) +{ + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); + testManager_->ConnectA2dpOffload(TEST_DEVICE_ADDR, TEST_SESSION_ID_VECTOR); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTING); +} + +/** + * @tc.name: ConnectA2dpOffload_003 + * @tc.desc: Test ConnectA2dpOffload with state disconnected. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, ConnectA2dpOffload_003, TestSize.Level1) +{ + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_DISCONNECTED); + testManager_->ConnectA2dpOffload(TEST_DEVICE_ADDR, TEST_SESSION_ID_VECTOR); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTING); +} + +/** + * @tc.name: WaitForConnectionCompleted_001 + * @tc.desc: Test WaitForConnectionCompleted with connection timeout. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, WaitForConnectionCompleted_001, TestSize.Level4) +{ + testManager_->ConnectA2dpOffload(TEST_DEVICE_ADDR, TEST_SESSION_ID_VECTOR); + testManager_->WaitForConnectionCompleted(); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTED); +} + +/** + * @tc.name: OffloadStartPlaying_001 + * @tc.desc: Test OffloadStartPlaying with entering the second if branch. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_001, TestSize.Level1) +{ + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_DISCONNECTED); + int32_t ret = testManager_->OffloadStartPlaying(TEST_SESSION_ID_VECTOR); + EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_DISCONNECTED); +} + +/** + * @tc.name: OffloadStartPlaying_002 + * @tc.desc: Test OffloadStartPlaying without entering the second if branch due to ret != SUCCESS. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_002, TestSize.Level1) +{ + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + int32_t ret = testManager_->OffloadStartPlaying(TEST_SESSION_ID_VECTOR); + EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_DISCONNECTED); +} + +/** + * @tc.name: OffloadStartPlaying_003 + * @tc.desc: Test OffloadStartPlaying without entering the second if branch due to + * state == CONNECTION_STATUS_CONNECTED. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_003, TestSize.Level1) +{ + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + int32_t ret = testManager_->OffloadStartPlaying(TEST_SESSION_ID_VECTOR); + EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); + EXPECT_EQ(testManager_->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTED); +} + +/** + * @tc.name: OffloadStartPlaying_004 + * @tc.desc: Test OffloadStartPlaying + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_004, TestSize.Level1) +{ + testManager_->SetA2dpOffloadFlag(A2DP_NOT_OFFLOAD); + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + int32_t ret = testManager_->OffloadStartPlaying(TEST_SESSION_ID_VECTOR); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name: OffloadStartPlaying_005 + * @tc.desc: Test OffloadStartPlaying + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_005, TestSize.Level1) +{ + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + std::vector sessionIds = {}; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + int32_t ret = testManager_->OffloadStartPlaying(sessionIds); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name: OffloadStopPlaying_001 + * @tc.desc: Test OffloadStopPlaying without entering the if branch. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStopPlaying_001, TestSize.Level1) +{ + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + int32_t ret = testManager_->OffloadStopPlaying(TEST_SESSION_ID_VECTOR); + EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); +} + +/** + * @tc.name: GetA2dpOffloadCodecAndSendToDsp_001 + * @tc.desc: Test GetA2dpOffloadCodecAndSendToDsp without entering the if branch. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetA2dpOffloadCodecAndSendToDsp_001, TestSize.Level1) +{ + AudioDeviceDescriptor deviceDescriptor; + deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER; + testManager_->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); + testManager_->GetA2dpOffloadCodecAndSendToDsp(); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: GetA2dpOffloadCodecAndSendToDsp_002 + * @tc.desc: Test GetA2dpOffloadCodecAndSendToDsp when entering the if branch. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetA2dpOffloadCodecAndSendToDsp_002, TestSize.Level1) +{ + AudioDeviceDescriptor deviceDescriptor; + deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER; + testManager_->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); + testManager_->GetA2dpOffloadCodecAndSendToDsp(); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_001 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_001, TestSize.Level1) +{ + int32_t playingState = 1; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + testManager_->OnA2dpPlayingStateChanged(TEST_DEVICE_ADDR, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_002 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_002, TestSize.Level1) +{ + int32_t playingState = 2; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + testManager_->OnA2dpPlayingStateChanged(TEST_DEVICE_ADDR, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_003 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_003, TestSize.Level1) +{ + int32_t playingState = 1; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); + testManager_->OnA2dpPlayingStateChanged(TEST_DEVICE_ADDR, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_004 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_004, TestSize.Level1) +{ + const std::string deviceAddress = testManager_->a2dpOffloadDeviceAddress_; + int32_t playingState = 2; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); + testManager_->OnA2dpPlayingStateChanged(deviceAddress, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_005 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_005, TestSize.Level1) +{ + const std::string deviceAddress = testManager_->a2dpOffloadDeviceAddress_; + int32_t playingState = 2; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + testManager_->OnA2dpPlayingStateChanged(deviceAddress, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_006 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_006, TestSize.Level1) +{ + const std::string deviceAddress = testManager_->a2dpOffloadDeviceAddress_; + int32_t playingState = 1; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + testManager_->OnA2dpPlayingStateChanged(deviceAddress, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: OnA2dpPlayingStateChanged_007 + * @tc.desc: Test OnA2dpPlayingStateChanged. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_007, TestSize.Level1) +{ + const std::string deviceAddress = testManager_->a2dpOffloadDeviceAddress_; + int32_t playingState = 3; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); + testManager_->OnA2dpPlayingStateChanged(deviceAddress, playingState); + EXPECT_NE(testManager_, nullptr); +} + +/** + * @tc.name: IsA2dpOffloadConnecting_001 + * @tc.desc: Test IsA2dpOffloadConnecting when entering the if branch. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, IsA2dpOffloadConnecting_001, TestSize.Level1) +{ + testManager_->connectionTriggerSessionIds_ = {TEST_STREAM_1_SESSION_ID}; + testManager_->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); + bool result = testManager_->IsA2dpOffloadConnecting(TEST_STREAM_1_SESSION_ID); + EXPECT_TRUE(result); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_GetA2dpOffloadFlag_001 + * @tc.number : GetA2dpOffloadFlag_001 + * @tc.desc : Test GetA2dpOffloadFlag() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetA2dpOffloadFlag_001, TestSize.Level3) +{ + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + EXPECT_EQ(A2DP_OFFLOAD, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForSpatializationChanged_001 + * @tc.number : UpdateA2dpOffloadFlagForSpatializationChanged_001 + * @tc.desc : Test UpdateA2dpOffloadFlagForSpatializationChanged() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForSpatializationChanged_001, TestSize.Level4) +{ + std::unordered_map testSpatializationEnabledMap; + testManager_->UpdateA2dpOffloadFlagForSpatializationChanged(testSpatializationEnabledMap, DEVICE_TYPE_SPEAKER); + EXPECT_EQ(A2DP_OFFLOAD, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForStartStream_001 + * @tc.number : UpdateA2dpOffloadFlagForStartStream_001 + * @tc.desc : Test UpdateA2dpOffloadFlagForStartStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForStartStream_001, TestSize.Level3) +{ + testManager_->UpdateA2dpOffloadFlagForStartStream(TEST_STREAM_1_SESSION_ID); + EXPECT_EQ(A2DP_OFFLOAD, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForStartStream_002 + * @tc.number : UpdateA2dpOffloadFlagForStartStream_002 + * @tc.desc : Test UpdateA2dpOffloadFlagForStartStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForStartStream_002, TestSize.Level3) +{ + uint32_t runningStreamCnt = 2; + uint32_t stopStreamCnt = 0; + MakeStreamCollectorData(runningStreamCnt, stopStreamCnt); + + testManager_->UpdateA2dpOffloadFlagForStartStream(TEST_SESSION_ID_BASE + runningStreamCnt); + EXPECT_EQ(NO_A2DP_DEVICE, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForStartStream_003 + * @tc.number : UpdateA2dpOffloadFlagForStartStream_003 + * @tc.desc : Test UpdateA2dpOffloadFlagForStartStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForStartStream_003, TestSize.Level3) +{ + uint32_t runningStreamCnt = 2; + uint32_t stopStreamCnt = 2; + MakeStreamCollectorData(runningStreamCnt, stopStreamCnt); + + testManager_->UpdateA2dpOffloadFlagForStartStream(TEST_SESSION_ID_BASE + runningStreamCnt); + EXPECT_EQ(NO_A2DP_DEVICE, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForStartStream_004 + * @tc.number : UpdateA2dpOffloadFlagForStartStream_004 + * @tc.desc : Test UpdateA2dpOffloadFlagForStartStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForStartStream_004, TestSize.Level3) +{ + uint32_t runningStreamCnt = 0; + uint32_t stopStreamCnt = 2; + MakeStreamCollectorData(runningStreamCnt, stopStreamCnt); + + testManager_->UpdateA2dpOffloadFlagForStartStream(TEST_SESSION_ID_BASE + runningStreamCnt); + EXPECT_EQ(NO_A2DP_DEVICE, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForAllStream_001 + * @tc.number : UpdateA2dpOffloadFlagForAllStream_001 + * @tc.desc : Test UpdateA2dpOffloadFlagForAllStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForAllStream_001, TestSize.Level4) +{ + testManager_->UpdateA2dpOffloadFlagForAllStream(DEVICE_TYPE_SPEAKER); + EXPECT_EQ(NO_A2DP_DEVICE, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForAllStream_002 + * @tc.number : UpdateA2dpOffloadFlagForAllStream_002 + * @tc.desc : Test UpdateA2dpOffloadFlagForAllStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForAllStream_002, TestSize.Level4) +{ + uint32_t runningStreamCnt = 2; + uint32_t stopStreamCnt = 2; + MakeStreamCollectorData(runningStreamCnt, stopStreamCnt); + + testManager_->UpdateA2dpOffloadFlagForAllStream(DEVICE_TYPE_BLUETOOTH_A2DP); + EXPECT_NE(A2DP_OFFLOAD, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForAllStream_003 + * @tc.number : UpdateA2dpOffloadFlagForAllStream_003 + * @tc.desc : Test UpdateA2dpOffloadFlagForAllStream() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForAllStream_003, TestSize.Level4) +{ + uint32_t runningStreamCnt = 2; + uint32_t stopStreamCnt = 2; + MakeStreamCollectorData(runningStreamCnt, stopStreamCnt); + + testManager_->SetA2dpOffloadFlag(A2DP_OFFLOAD); + testManager_->UpdateA2dpOffloadFlagForAllStream(DEVICE_TYPE_BLUETOOTH_A2DP); + EXPECT_NE(A2DP_OFFLOAD, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_GetSpatialAudio_001 + * @tc.number : GetSpatialAudio_001 + * @tc.desc : Test GetSpatialAudio() for different cases + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetSpatialAudio_001, TestSize.Level4) +{ + std::unordered_map testSpatializationEnabledMap; + bool isSpatial = testManager_->GetSpatialAudio(true, TEST_STREAM_1_SESSION_ID, + STREAM_USAGE_MUSIC, testSpatializationEnabledMap); + EXPECT_EQ(false, isSpatial); + + isSpatial = testManager_->GetSpatialAudio(false, TEST_STREAM_1_SESSION_ID, + STREAM_USAGE_MUSIC, testSpatializationEnabledMap); + EXPECT_EQ(false, isSpatial); + + testSpatializationEnabledMap[TEST_STREAM_1_SESSION_ID] = true; + isSpatial = testManager_->GetSpatialAudio(false, TEST_STREAM_1_SESSION_ID, + STREAM_USAGE_MUSIC, testSpatializationEnabledMap); + EXPECT_EQ(true, isSpatial); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_UpdateA2dpOffloadFlagForA2dpDeviceOut_001 + * @tc.number : UpdateA2dpOffloadFlagForA2dpDeviceOut_001 + * @tc.desc : Test UpdateA2dpOffloadFlagForA2dpDeviceOut() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForA2dpDeviceOut_001, TestSize.Level4) +{ + uint32_t runningStreamCnt = 1; + uint32_t stopStreamCnt = 1; + MakeStreamCollectorData(runningStreamCnt, stopStreamCnt); + + testManager_->UpdateA2dpOffloadFlagForA2dpDeviceOut(); + EXPECT_EQ(NO_A2DP_DEVICE, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_HandleA2dpDeviceOutOffload_001 + * @tc.number : HandleA2dpDeviceOutOffload_001 + * @tc.desc : Test HandleA2dpDeviceOutOffload() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleA2dpDeviceOutOffload_001, TestSize.Level4) +{ + std::vector testRunningSessions = { + TEST_STREAM_1_SESSION_ID, + TEST_STREAM_2_SESSION_ID + }; + testManager_->HandleA2dpDeviceOutOffload(NO_A2DP_DEVICE, testRunningSessions); + EXPECT_EQ(NO_A2DP_DEVICE, testManager_->GetA2dpOffloadFlag()); +} + +/** + * @tc.name : AudioA2dpOffloadManagerUnitTest_HandleA2dpDeviceInOffload_001 + * @tc.number : HandleA2dpDeviceInOffload_001 + * @tc.desc : Test HandleA2dpDeviceInOffload() + */ +HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleA2dpDeviceInOffload_001, TestSize.Level4) +{ + std::vector testRunningSessions = { + TEST_STREAM_1_SESSION_ID, + TEST_STREAM_2_SESSION_ID + }; + testManager_->HandleA2dpDeviceInOffload(A2DP_OFFLOAD, testRunningSessions); + EXPECT_EQ(A2DP_OFFLOAD, testManager_->GetA2dpOffloadFlag()); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_a2dp_offload_manager_unit_test/include/audio_a2dp_offload_manager_unit_test.h b/services/audio_policy/server/domain/pipe/test/unittest/audio_a2dp_offload_manager_unit_test.h similarity index 89% rename from services/audio_policy/test/unittest/audio_a2dp_offload_manager_unit_test/include/audio_a2dp_offload_manager_unit_test.h rename to services/audio_policy/server/domain/pipe/test/unittest/audio_a2dp_offload_manager_unit_test.h index a660b1bf219bc5c633aef8893d41a1a32093f98a..bfd2ab2e3c3f5abfc302f0491db10c330f70b45b 100644 --- a/services/audio_policy/test/unittest/audio_a2dp_offload_manager_unit_test/include/audio_a2dp_offload_manager_unit_test.h +++ b/services/audio_policy/server/domain/pipe/test/unittest/audio_a2dp_offload_manager_unit_test.h @@ -15,6 +15,7 @@ #ifndef AUDIO_A2DP_OFFLOAD_MANAGER_UNIT_TEST_H #define AUDIO_A2DP_OFFLOAD_MANAGER_UNIT_TEST_H + #include "gtest/gtest.h" #include "audio_a2dp_offload_manager.h" @@ -31,6 +32,11 @@ public: void SetUp(void); // TearDown: Called after each test cases void TearDown(void); + +private: + void MakeStreamCollectorData(uint32_t runningStreamCnt, uint32_t stopStreamCnt); + + std::shared_ptr testManager_; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/domain/pipe/test/unittest/audio_capturer_session_unit_test/include/audio_capturer_session_ext_unit_test.h b/services/audio_policy/server/domain/pipe/test/unittest/audio_capturer_session_unit_test/include/audio_capturer_session_ext_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..86ef38ad38ab74ece7fbcbb1d1bbd3f4ec954717 --- /dev/null +++ b/services/audio_policy/server/domain/pipe/test/unittest/audio_capturer_session_unit_test/include/audio_capturer_session_ext_unit_test.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_CAPTURER_SESSION_EXT_UNIT_TEST_H +#define AUDIO_CAPTURER_SESSION_EXT_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_capturer_session.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioCapturerSessionExtTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); + +private: + std::shared_ptr audioCapturerSession_ = nullptr; +}; + +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_CAPTURER_SESSION_EXT_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_ext_unit_test.cpp b/services/audio_policy/server/domain/pipe/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_ext_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..3d533cd8870a17da17e937090576abec52795b7a --- /dev/null +++ b/services/audio_policy/server/domain/pipe/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_ext_unit_test.cpp @@ -0,0 +1,256 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_capturer_session_ext_unit_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +constexpr uint32_t THP_EXTRA_SA_UID = 5000; +const std::string PIPE_WAKEUP_INPUT = "wakeup_input"; + +void AudioCapturerSessionExtTest::SetUpTestCase(void) {} +void AudioCapturerSessionExtTest::TearDownTestCase(void) {} + +void AudioCapturerSessionExtTest::SetUp(void) +{ + audioCapturerSession_ = std::make_shared(); + EXPECT_NE(audioCapturerSession_, nullptr); +} + +void AudioCapturerSessionExtTest::TearDown(void) +{ + audioCapturerSession_ = nullptr; +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: FindRunningNormalSession_001 + * @tc.desc : Test !info || sessionWithNormalSourceType_.find(info->sessionId) == sessionWithNormalSourceType_.end() + */ +HWTEST_F(AudioCapturerSessionExtTest, FindRunningNormalSession_001, TestSize.Level4) +{ + AudioStreamCollector &streamCollector = AudioStreamCollector::GetAudioStreamCollector(); + auto info1 = std::make_shared(); + info1->clientUID = THP_EXTRA_SA_UID + 1; + auto info2 = std::make_shared(); + info2->clientUID = THP_EXTRA_SA_UID + 2; + streamCollector.audioCapturerChangeInfos_ = { info1, info2 }; + + audioCapturerSession_->sessionWithNormalSourceType_.insert({ info2->sessionId, SessionInfo() }); + AudioStreamDescriptor runningSessionInfo; + EXPECT_FALSE(audioCapturerSession_->FindRunningNormalSession(info1->sessionId, runningSessionInfo)); + EXPECT_FALSE(audioCapturerSession_->FindRunningNormalSession(info2->sessionId, runningSessionInfo)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadCaptureSession_001 + * @tc.desc : Test sessionWithNormalSourceType_.count(sessionId) == 0 || + * (specialSourceTypeSet_.count(sessionWithNormalSourceType_[sessionId].sourceType) != 0) + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadCaptureSession_001, TestSize.Level4) +{ + uint32_t sessionId = 1001; + SessionOperation operation = SessionOperation::SESSION_OPERATION_START; + audioCapturerSession_->sessionWithNormalSourceType_.clear(); + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); + + SessionInfo sessionInfo; + sessionInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE; + audioCapturerSession_->sessionWithNormalSourceType_[sessionId] = sessionInfo; + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadCaptureSession_002 + * @tc.desc : Test operation == SESSION_OPERATION_START + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadCaptureSession_002, TestSize.Level4) +{ + uint32_t sessionId = 1001; + SessionOperation operation = SessionOperation::SESSION_OPERATION_START; + SessionInfo sessionInfo; + sessionInfo.sourceType = SOURCE_TYPE_INVALID; + audioCapturerSession_->sessionWithNormalSourceType_[sessionId] = sessionInfo; + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); + + sessionInfo.sourceType = SOURCE_TYPE_VOICE_CALL; + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadCaptureSession_003 + * @tc.desc : Test operation == SESSION_OPERATION_PAUSE or SESSION_OPERATION_STOP + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadCaptureSession_003, TestSize.Level4) +{ + uint32_t sessionId = 1001; + SessionOperation operation = SessionOperation::SESSION_OPERATION_PAUSE; + SessionInfo sessionInfo; + sessionInfo.sourceType = SOURCE_TYPE_INVALID; + audioCapturerSession_->sessionWithNormalSourceType_[sessionId] = sessionInfo; + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); + + sessionInfo.sourceType = SOURCE_TYPE_VOICE_CALL; + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadCaptureSession_004 + * @tc.desc : Test operation == SESSION_OPERATION_RELEASE + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadCaptureSession_004, TestSize.Level4) +{ + uint32_t sessionId = 1001; + SessionOperation operation = SessionOperation::SESSION_OPERATION_RELEASE; + SessionInfo sessionInfo; + sessionInfo.sourceType = SOURCE_TYPE_INVALID; + audioCapturerSession_->sessionWithNormalSourceType_[sessionId] = sessionInfo; + EXPECT_EQ(audioCapturerSession_->ReloadCaptureSession(sessionId, operation), ERROR); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ConstructWakeupAudioModuleInfo_001 + * @tc.desc : Test audioConfigManager_.GetAdapterInfoByType(type, info) == false + */ +HWTEST_F(AudioCapturerSessionExtTest, ConstructWakeupAudioModuleInfo_001, TestSize.Level4) +{ + audioCapturerSession_->audioConfigManager_.isAdapterInfoMap_ = true; + audioCapturerSession_->audioConfigManager_.audioPolicyConfig_.adapterInfoMap.clear(); + AudioStreamInfo streamInfo; + AudioModuleInfo audioModuleInfo; + EXPECT_FALSE(audioCapturerSession_->ConstructWakeupAudioModuleInfo(streamInfo, audioModuleInfo)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ConstructWakeupAudioModuleInfo_002 + * @tc.desc : Test pipeInfo == nullptr + */ +HWTEST_F(AudioCapturerSessionExtTest, ConstructWakeupAudioModuleInfo_002, TestSize.Level4) +{ + audioCapturerSession_->audioConfigManager_.isAdapterInfoMap_ = true; + std::shared_ptr audioAdapterInfo = std::make_shared(); + audioAdapterInfo->pipeInfos.clear(); + audioCapturerSession_->audioConfigManager_.audioPolicyConfig_.adapterInfoMap.emplace( + AudioAdapterType::TYPE_PRIMARY, audioAdapterInfo); + AudioStreamInfo streamInfo; + AudioModuleInfo audioModuleInfo; + EXPECT_FALSE(audioCapturerSession_->ConstructWakeupAudioModuleInfo(streamInfo, audioModuleInfo)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ConstructWakeupAudioModuleInfo_003 + * @tc.desc : Test FillWakeupStreamPropInfo(streamInfo, pipeInfo, audioModuleInfo) == false + */ +HWTEST_F(AudioCapturerSessionExtTest, ConstructWakeupAudioModuleInfo_003, TestSize.Level4) +{ + audioCapturerSession_->audioConfigManager_.isAdapterInfoMap_ = true; + std::shared_ptr audioAdapterInfo = std::make_shared(); + std::shared_ptr pipeInfo = std::make_shared(); + pipeInfo->name_ = PIPE_WAKEUP_INPUT; + pipeInfo->streamPropInfos_.clear(); + audioAdapterInfo->pipeInfos.push_back(pipeInfo); + audioCapturerSession_->audioConfigManager_.audioPolicyConfig_.adapterInfoMap.emplace( + AudioAdapterType::TYPE_PRIMARY, audioAdapterInfo); + AudioStreamInfo streamInfo; + AudioModuleInfo audioModuleInfo; + EXPECT_FALSE(audioCapturerSession_->ConstructWakeupAudioModuleInfo(streamInfo, audioModuleInfo)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadSourceForDeviceChange_001 + * @tc.desc : Test sessionWithNormalSourceType_.find(sessionId) != sessionWithNormalSourceType_.end() + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadSourceForDeviceChange_001, TestSize.Level4) +{ + AudioDeviceDescriptor inputDevice; + inputDevice.deviceType_ = DEVICE_TYPE_INVALID; + AudioDeviceDescriptor outputDevice; + std::string caller = "test"; + audioCapturerSession_->audioEcManager_.isEcFeatureEnable_ = true; + audioCapturerSession_->audioEcManager_.normalSourceOpened_ = SOURCE_TYPE_MIC; + uint32_t sessionId = 1001; + audioCapturerSession_->audioEcManager_.sessionIdUsedToOpenSource_ = sessionId; + audioCapturerSession_->sessionWithNormalSourceType_[sessionId] = SessionInfo(); + EXPECT_NO_THROW(audioCapturerSession_->ReloadSourceForDeviceChange(inputDevice, outputDevice, caller)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: GetEnhancePropByName_001 + * @tc.desc : Test iter == propertyArray.property.end() + */ +HWTEST_F(AudioCapturerSessionExtTest, GetEnhancePropByName_001, TestSize.Level4) +{ + AudioEnhancePropertyArray propertyArray; + AudioEnhanceProperty property; + property.enhanceClass = "testClass"; + propertyArray.property.push_back(property); + std::string propName = "testProperty"; + EXPECT_EQ(audioCapturerSession_->GetEnhancePropByName(propertyArray, propName), ""); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadSourceForEffect_001 + * @tc.desc : Test audioEcManager_.GetMicRefFeatureEnable() == false + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadSourceForEffect_001, TestSize.Level4) +{ + AudioEnhancePropertyArray oldPropertyArray; + AudioEnhancePropertyArray newPropertyArray; + audioCapturerSession_->audioEcManager_.isMicRefFeatureEnable_ = false; + EXPECT_NO_THROW(audioCapturerSession_->ReloadSourceForEffect(oldPropertyArray, newPropertyArray)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadSourceForEffect_002 + * @tc.desc : Test audioEcManager_.GetSourceOpened() != SOURCE_TYPE_MIC + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadSourceForEffect_002, TestSize.Level4) +{ + AudioEnhancePropertyArray oldPropertyArray; + AudioEnhancePropertyArray newPropertyArray; + audioCapturerSession_->audioEcManager_.isMicRefFeatureEnable_ = true; + audioCapturerSession_->audioEcManager_.normalSourceOpened_ = SOURCE_TYPE_VOICE_COMMUNICATION; + EXPECT_NO_THROW(audioCapturerSession_->ReloadSourceForEffect(oldPropertyArray, newPropertyArray)); +} + +/** + * @tc.name : Test AudioCapturerSession. + * @tc.number: ReloadSourceForEffect_003 + * @tc.desc : Test audioEcManager_.GetSourceOpened() == SOURCE_TYPE_INVALID + */ +HWTEST_F(AudioCapturerSessionExtTest, ReloadSourceForEffect_003, TestSize.Level4) +{ + AudioEnhancePropertyArray oldPropertyArray; + AudioEnhancePropertyArray newPropertyArray; + audioCapturerSession_->audioEcManager_.isMicRefFeatureEnable_ = true; + audioCapturerSession_->audioEcManager_.normalSourceOpened_ = SOURCE_TYPE_INVALID; + EXPECT_NO_THROW(audioCapturerSession_->ReloadSourceForEffect(oldPropertyArray, newPropertyArray)); +} +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/server/domain/pipe/test/unittest/audio_offload_stream_unit_test.cpp b/services/audio_policy/server/domain/pipe/test/unittest/audio_offload_stream_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b797d9048bc0eb28aee250ac5fc3ee9712694960 --- /dev/null +++ b/services/audio_policy/server/domain/pipe/test/unittest/audio_offload_stream_unit_test.cpp @@ -0,0 +1,213 @@ +/* + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_offload_stream_unit_test.h" + +#include +#include "gtest/gtest.h" +#include "audio_errors.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +static const uint32_t TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID = 100000; +static const uint32_t TEST_OFFLOAD_IN_PRIMARY_2_SESSION_ID = 100001; +static const uint32_t TEST_OFFLOAD_IN_REMOTE_1_SESSION_ID = 100002; +static const uint32_t TEST_OFFLOAD_IN_REMOTE_2_SESSION_ID = 100003; + +void AudioOffloadStreamTest::SetUpTestCase(void) {} + +void AudioOffloadStreamTest::TearDownTestCase(void) {} + +void AudioOffloadStreamTest::SetUp(void) +{ + testOffloadModule_ = std::make_shared(); +} + +void AudioOffloadStreamTest::TearDown(void) +{ + testOffloadModule_ = nullptr; +} + +/** + * @tc.name : HandlePowerStateChanged_NoChange_Test + * @tc.number: AudioOffloadStreamTest_001 + * @tc.desc : Test scenario where the power state does not change. + */ +HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoChange_Test, TestSize.Level2) +{ + testOffloadModule_->currentPowerState_ = PowerMgr::PowerState::FREEZE; + PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; + testOffloadModule_->HandlePowerStateChanged(state); + EXPECT_EQ(testOffloadModule_->currentPowerState_, PowerMgr::PowerState::FREEZE); +} + +/** + * @tc.name : HandlePowerStateChanged_ActiveToInactive_Test + * @tc.number: AudioOffloadStreamTest_002 + * @tc.desc : Test scenario where the power state changes from ACTIVE to INACTIVE. + */ +HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_ActiveToInactive_Test, TestSize.Level2) +{ + testOffloadModule_->currentPowerState_ = PowerMgr::PowerState::FREEZE; + PowerMgr::PowerState state = PowerMgr::PowerState::INACTIVE; + testOffloadModule_->HandlePowerStateChanged(state); + EXPECT_EQ(testOffloadModule_->currentPowerState_, PowerMgr::PowerState::INACTIVE); +} + +/** + * @tc.name : HandlePowerStateChanged_NoOffloadSupport_Test + * @tc.number: AudioOffloadStreamTest_003 + * @tc.desc : Test scenario where the device does not support offload. + */ +HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoOffloadSupport_Test, TestSize.Level3) +{ + testOffloadModule_->currentPowerState_ = PowerMgr::PowerState::FREEZE; + PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; + testOffloadModule_->HandlePowerStateChanged(state); + EXPECT_EQ(testOffloadModule_->currentPowerState_, PowerMgr::PowerState::FREEZE); +} + +/** + * @tc.name : HandlePowerStateChanged_OffloadSessionIDNotSet_Test + * @tc.number: audioOffloadStreamTest_004 + * @tc.desc : Test scenario where the offload session ID is not set. + */ +HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDNotSet_Test, TestSize.Level3) +{ + testOffloadModule_->currentPowerState_ = PowerMgr::PowerState::FREEZE; + PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; + testOffloadModule_->HandlePowerStateChanged(state); + EXPECT_EQ(testOffloadModule_->currentPowerState_, PowerMgr::PowerState::FREEZE); +} + +/** + * @tc.name : AudioOffloadStreamTest_013 + * @tc.number: AudioOffloadStreamTest_013 + * @tc.desc : Test FilterSinkInputs function + */ +HWTEST_F(AudioOffloadStreamTest, FilterSinkInputs_ShouldReturnEmpty_WhenSinkInputsIsEmpty, TestSize.Level4) +{ + AudioOffloadStream testModule; + std::vector sinkInputs; + std::vector result = testModule.FilterSinkInputs(1, sinkInputs); + EXPECT_TRUE(result.empty()); + SinkInput sinkInput; + sinkInput.uid = 123; + sinkInput.streamType = AudioStreamType::STREAM_DEFAULT; + sinkInputs.push_back(sinkInput); + + result = testModule.FilterSinkInputs(1, sinkInputs); + EXPECT_TRUE(result.empty()); + sinkInput.streamId = 1; + sinkInputs.push_back(sinkInput); + + result = testModule.FilterSinkInputs(1, sinkInputs); + EXPECT_EQ(result.size(), 0); +} + +/** + * @tc.name : AudioOffloadStreamTest_GetInstance_001 + * @tc.number : GetInstance_001 + * @tc.desc : Test GetInstance() + */ +HWTEST_F(AudioOffloadStreamTest, GetInstance_001, TestSize.Level3) +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + EXPECT_EQ(OFFLOAD_IN_ADAPTER_SIZE, testModule.offloadSessionIdMap_.size()); +} + +/** + * @tc.name : AudioOffloadStreamTest_GetOffloadSessionId_001 + * @tc.number : GetOffloadSessionId_001 + * @tc.desc : Test GetOffloadSessionId() abnormal cases + */ +HWTEST_F(AudioOffloadStreamTest, GetOffloadSessionId_001, TestSize.Level3) +{ + EXPECT_EQ(NO_OFFLOAD_STREAM_SESSIONID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); + EXPECT_EQ(NO_OFFLOAD_STREAM_SESSIONID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_REMOTE)); +} + +/** + * @tc.name : AudioOffloadStreamTest_SetOffloadStatus_001 + * @tc.number : SetOffloadStatus_001 + * @tc.desc : Test SetOffloadStatus() in normal situation + */ +HWTEST_F(AudioOffloadStreamTest, SetOffloadStatus_001, TestSize.Level2) +{ + testOffloadModule_->SetOffloadStatus(OFFLOAD_IN_PRIMARY, TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID); + EXPECT_EQ(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); + testOffloadModule_->UnsetOffloadStatus(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID); + EXPECT_EQ(NO_OFFLOAD_STREAM_SESSIONID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioOffloadStreamTest_SetOffloadStatus_002 + * @tc.number : SetOffloadStatus_002 + * @tc.desc : Test SetOffloadStatus() in abnormal situation + */ +HWTEST_F(AudioOffloadStreamTest, SetOffloadStatus_002, TestSize.Level3) +{ + testOffloadModule_->SetOffloadStatus(OFFLOAD_IN_PRIMARY, TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID); + EXPECT_EQ(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); + testOffloadModule_->SetOffloadStatus(OFFLOAD_IN_REMOTE, TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID); + EXPECT_EQ(NO_OFFLOAD_STREAM_SESSIONID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); + EXPECT_EQ(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_REMOTE)); +} + +/** + * @tc.name : AudioOffloadStreamTest_UpdateOffloadStatusFromUpdateTracker_001 + * @tc.number : UpdateOffloadStatusFromUpdateTracker_001 + * @tc.desc : Test UpdateOffloadStatusFromUpdateTracker() in normal situation + */ +HWTEST_F(AudioOffloadStreamTest, UpdateOffloadStatusFromUpdateTracker_001, TestSize.Level2) +{ + testOffloadModule_->SetOffloadStatus(OFFLOAD_IN_PRIMARY, TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID); + + testOffloadModule_->UpdateOffloadStatusFromUpdateTracker(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, RENDERER_STOPPED); + EXPECT_EQ(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); + + testOffloadModule_->UpdateOffloadStatusFromUpdateTracker(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, RENDERER_RUNNING); + EXPECT_EQ(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioOffloadStreamTest_UpdateOffloadStatusFromUpdateTracker_002 + * @tc.number : UpdateOffloadStatusFromUpdateTracker_002 + * @tc.desc : Test UpdateOffloadStatusFromUpdateTracker() in abnormal stream situation + */ +HWTEST_F(AudioOffloadStreamTest, UpdateOffloadStatusFromUpdateTracker_002, TestSize.Level4) +{ + testOffloadModule_->SetOffloadStatus(OFFLOAD_IN_PRIMARY, TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID); + testOffloadModule_->UpdateOffloadStatusFromUpdateTracker(TEST_OFFLOAD_IN_PRIMARY_2_SESSION_ID, RENDERER_RUNNING); + EXPECT_EQ(TEST_OFFLOAD_IN_PRIMARY_1_SESSION_ID, testOffloadModule_->GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioOffloadStreamTest_Dump_001 + * @tc.number : Dump_001 + * @tc.desc : Test Dump() in abnormal situation + */ +HWTEST_F(AudioOffloadStreamTest, Dump_001, TestSize.Level3) +{ + std::string dumpStr; + testOffloadModule_->Dump(dumpStr); + EXPECT_NE("", dumpStr); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_offload_stream_unit_test/include/audio_offload_stream_unit_test.h b/services/audio_policy/server/domain/pipe/test/unittest/audio_offload_stream_unit_test.h similarity index 91% rename from services/audio_policy/test/unittest/audio_offload_stream_unit_test/include/audio_offload_stream_unit_test.h rename to services/audio_policy/server/domain/pipe/test/unittest/audio_offload_stream_unit_test.h index fc461f47276228e8be0193ecc99090977548c823..c937fa1f44a83e92148526be7a2adc418d465f5a 100644 --- a/services/audio_policy/test/unittest/audio_offload_stream_unit_test/include/audio_offload_stream_unit_test.h +++ b/services/audio_policy/server/domain/pipe/test/unittest/audio_offload_stream_unit_test.h @@ -32,9 +32,9 @@ public: // TearDown: Called after each test cases void TearDown(void); -protected: - AudioOffloadStream *audioOffloadStream_; +private: + std::shared_ptr testOffloadModule_; }; } // namespace AudioStandard } // namespace OHOS -#endif // AUDIO_OFFLOAD_STREAM_UNIT_TEST_H \ No newline at end of file +#endif // AUDIO_OFFLOAD_STREAM_UNIT_TEST_H diff --git a/services/audio_policy/server/domain/router/test/BUILD.gn b/services/audio_policy/server/domain/router/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..777716a2c715334d15e1fd17030947f2e1bf5ef2 --- /dev/null +++ b/services/audio_policy/server/domain/router/test/BUILD.gn @@ -0,0 +1,355 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../../accessibility.gni") +import("../../../../../../appgallery.gni") +import("../../../../../../bluetooth_part.gni") +import("../../../../../../config.gni") + +group("audio_router_unittest_packages") { + testonly = true + deps = [ + ":public_priority_router_unit_test", + ":pair_device_router_unit_test", + ":stream_filter_router_ext_unit_test", + ] +} + +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +ohos_unittest("public_priority_router_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./unittest/public_priority_router_unit_test/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "distributed_notification_service:ans_innerkits", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./unittest/public_priority_router_unit_test/src/public_priority_router_unit_test.cpp" ] + + deps = [ + "../../../../../audio_policy:audio_policy_client", + "../../../../../audio_policy:audio_policy_service_static", + "../../../../../audio_service:audio_client", + "../../../../../audio_service:audio_common", + ] + + if (bluetooth_part_enable == true) { + deps += + [ "../../../../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } +} + +ohos_unittest("pair_device_router_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./unittest/pair_device_router_unit_test/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "distributed_notification_service:ans_innerkits", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./unittest/pair_device_router_unit_test/src/pair_device_router_unit_test.cpp" ] + + deps = [ + "../../../../../audio_policy:audio_policy_client", + "../../../../../audio_policy:audio_policy_service_static", + "../../../../../audio_service:audio_client", + "../../../../../audio_service:audio_common", + ] + + if (bluetooth_part_enable == true) { + deps += + [ "../../../../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } +} + +ohos_unittest("stream_filter_router_ext_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./unittest/stream_filter_router_unit_test/include", + "../../../common/definitions/include", + "../../../../../../frameworks/native/audiodefinitions/include", + "../../../../../audio_service/common/include/dfx", + "../../../../../audio_policy/server/include/service", + "../../../../../audio_policy/server/include/service/listener", + "../../../../../audio_policy/server/include/service/service", + "../../../../../audio_policy/server/domain/device/include", + "../../../../../audio_policy/server/domain/device/src/a2dp", + "../../../../../audio_policy/server/include", + ] + + use_exceptions = true + testonly = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "pulseaudio:pulse", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", + "ability_runtime:wantagent_innerkits", + ] + + public_external_deps = [ "ffrt:libffrt" ] + + public_external_deps += [ + "libxml2:libxml2", + "openssl:libcrypto_shared", + ] + + sources = [ + "./unittest/stream_filter_router_unit_test/src/stream_filter_router_ext_unit_test.cpp", + ] + + configs = [ "../../../../../../services/audio_policy:audio_policy_public_config" ] + + deps = [ + "../../../../../../services/audio_service/idl:audio_framework_interface", + "../../../../../../services/audio_policy:audio_policy_client", + "../../../../../../services/audio_policy:audio_policy_service_static", + "../../../../../../services/audio_service:audio_client", + ] + + defines = [] + + if (build_variant == "user") { + defines += [ "AUDIO_BUILD_VARIANT_USER" ] + } else if (build_variant == "root") { + defines += [ "AUDIO_BUILD_VARIANT_ROOT" ] + } + + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } + + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } + + if (audio_framework_feature_dtmf_tone) { + defines += [ "FEATURE_DTMF_TONE" ] + } + + if (audio_framework_feature_usb_audio) { + defines += [ "USB_ENABLE" ] + external_deps += [ "usb_manager:usbsrv_client" ] + } + + if (audio_framework_config_policy_enable) { + defines += [ "USE_CONFIG_POLICY" ] + external_deps += [ "config_policy:configpolicy_util" ] + } + + if (bluetooth_part_enable == true) { + deps += + [ "../../../../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } + + if (audio_framework_feature_wired_audio) { + defines += [ "AUDIO_WIRED_DETECT" ] + } + + if (audio_framework_feature_inner_capturer) { + defines += [ "HAS_FEATURE_INNERCAPTURER" ] + } + + if (audio_framework_feature_offline_effect) { + defines += [ "FEATURE_OFFLINE_EFFECT" ] + } + + if (audio_framework_feature_distributed_audio) { + defines += [ "FEATURE_DISTRIBUTE_AUDIO" ] + } + + if (audio_framework_feature_file_io == true) { + defines += [ "FEATURE_FILE_IO" ] + } + + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } + + if (audio_framework_feature_input) { + defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] + external_deps += [ "input:libmmi-client" ] + } + + if (audio_framework_feature_device_manager) { + defines += [ "FEATURE_DEVICE_MANAGER" ] + external_deps += [ "device_manager:devicemanagersdk" ] + } + + if (bluetooth_part_enable == true) { + cflags += [ "-DBLUETOOTH_ENABLE" ] + } +} \ No newline at end of file diff --git a/services/audio_policy/server/domain/router/test/unittest/pair_device_router_unit_test/include/pair_device_router_unit_test.h b/services/audio_policy/server/domain/router/test/unittest/pair_device_router_unit_test/include/pair_device_router_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..3c3a78927130bfe4f620d04f0cf71d5dcca7fcc3 --- /dev/null +++ b/services/audio_policy/server/domain/router/test/unittest/pair_device_router_unit_test/include/pair_device_router_unit_test.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PAIR_DEVICE_ROUTER_UNIT_TEST_H +#define PAIR_DEVICE_ROUTER_UNIT_TEST_H + +#include +#include "audio_bluetooth_manager.h" +#include "audio_device_info.h" +#include "audio_policy_service.h" +#include "audio_system_manager.h" +#include "pair_device_router.h" + +namespace OHOS { +namespace AudioStandard { + +class PairDeviceRouterUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // PAIR_DEVICE_ROUTER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/domain/router/test/unittest/pair_device_router_unit_test/src/pair_device_router_unit_test.cpp b/services/audio_policy/server/domain/router/test/unittest/pair_device_router_unit_test/src/pair_device_router_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e3d7f7f0752f8c78279ec00e4d7c33a30900a823 --- /dev/null +++ b/services/audio_policy/server/domain/router/test/unittest/pair_device_router_unit_test/src/pair_device_router_unit_test.cpp @@ -0,0 +1,193 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "pair_device_router_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" + +#include +#include +#include + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void PairDeviceRouterUnitTest::SetUpTestCase(void) {} +void PairDeviceRouterUnitTest::TearDownTestCase(void) {} +void PairDeviceRouterUnitTest::SetUp(void) {} +void PairDeviceRouterUnitTest::TearDown(void) {} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_001 + * @tc.desc : Test PairDeviceRouter GetMediaRenderDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_001, TestSize.Level4) +{ + PairDeviceRouter router; + auto dev = router.GetMediaRenderDevice(STREAM_USAGE_MEDIA, 0); + ASSERT_NE(dev, nullptr); + EXPECT_EQ(dev->getType(), DeviceType::DEVICE_TYPE_NONE); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_002 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_002, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::CONNECTED; + pairDev->exceptionFlag_ = true; + pairDev->isEnable_ = true; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 101, 201); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_003 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_003, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::CONNECTED; + pairDev->exceptionFlag_ = true; + pairDev->isEnable_ = false; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 102, 202); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_004 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_004, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::CONNECTED; + pairDev->exceptionFlag_ = false; + pairDev->isEnable_ = true; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 103, 203); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_005 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_005, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::CONNECTED; + pairDev->exceptionFlag_ = false; + pairDev->isEnable_ = false; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 104, 104); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_006 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_006, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::SUSPEND_CONNECTED; + pairDev->exceptionFlag_ = true; + pairDev->isEnable_ = true; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 105, 205); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_007 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_007, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::SUSPEND_CONNECTED; + pairDev->exceptionFlag_ = true; + pairDev->isEnable_ = false; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 106, 206); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_008 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_008, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::SUSPEND_CONNECTED; + pairDev->exceptionFlag_ = false; + pairDev->isEnable_ = true; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 107, 207); + ASSERT_NE(dev, nullptr); +} + +/** + * @tc.name : Test PairDeviceRouter. + * @tc.number: PairDeviceRouter_009 + * @tc.desc : Test PairDeviceRouter GetCallCaptureDevice interface. + */ +HWTEST(PairDeviceRouterUnitTest, PairDeviceRouter_009, TestSize.Level4) +{ + auto pairDev = std::make_shared(); + pairDev->connectState_ = ConnectState::SUSPEND_CONNECTED; + pairDev->exceptionFlag_ = false; + pairDev->isEnable_ = false; + pairDev->deviceType_ = DeviceType::DEVICE_TYPE_USB_ARM_HEADSET; + + PairDeviceRouter router; + auto dev = router.GetCallCaptureDevice(static_cast(0), 108, 208); + ASSERT_NE(dev, nullptr); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/domain/router/test/unittest/public_priority_router_unit_test/include/public_priority_router_unit_test.h b/services/audio_policy/server/domain/router/test/unittest/public_priority_router_unit_test/include/public_priority_router_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..ce8c85f12a14771b6522761a82ac690845c5d60a --- /dev/null +++ b/services/audio_policy/server/domain/router/test/unittest/public_priority_router_unit_test/include/public_priority_router_unit_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PUBLIC_PRIORITY_ROUTER_UNIT_TEST_H +#define PUBLIC_PRIORITY_ROUTER_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_system_manager.h" +#include "public_priority_router.h" + +namespace OHOS { +namespace AudioStandard { + +class PublicPriorityRouterUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // PUBLIC_PRIORITY_ROUTER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/domain/router/test/unittest/public_priority_router_unit_test/src/public_priority_router_unit_test.cpp b/services/audio_policy/server/domain/router/test/unittest/public_priority_router_unit_test/src/public_priority_router_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8ea94bfaa2b7e0d8a7645e43471a6ced6aa2831d --- /dev/null +++ b/services/audio_policy/server/domain/router/test/unittest/public_priority_router_unit_test/src/public_priority_router_unit_test.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "public_priority_router_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" + +#include +#include +#include +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void PublicPriorityRouterUnitTest::SetUpTestCase(void) {} +void PublicPriorityRouterUnitTest::TearDownTestCase(void) {} +void PublicPriorityRouterUnitTest::SetUp(void) {} +void PublicPriorityRouterUnitTest::TearDown(void) {} + +/** + * @tc.name : Test PublicPriorityRouter. + * @tc.number: PublicPriorityRouter_001 + * @tc.desc : Test PublicPriorityRouter GetMediaRenderDevice interface. + */ +HWTEST(PublicPriorityRouterUnitTest, PublicPriorityRouter_001, TestSize.Level4) +{ + PublicPriorityRouter router; + auto ret = router.GetMediaRenderDevice(STREAM_USAGE_RINGTONE, 101); + EXPECT_NE(ret, nullptr); + ret = router.GetMediaRenderDevice(STREAM_USAGE_VOICE_RINGTONE, 102); + EXPECT_NE(ret, nullptr); + ret = router.GetMediaRenderDevice(STREAM_USAGE_MEDIA, 103); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PublicPriorityRouter. + * @tc.number: PublicPriorityRouter_002 + * @tc.desc : Test PublicPriorityRouter GetMediaRenderDevice interface. + */ +HWTEST(PublicPriorityRouterUnitTest, PublicPriorityRouter_002, TestSize.Level4) +{ + PublicPriorityRouter router; + auto ret = router.GetRingRenderDevices(STREAM_USAGE_MEDIA, 100); + ASSERT_EQ(ret.size(), 1u); + ASSERT_NE(ret[0], nullptr); + ret = router.GetRingRenderDevices(STREAM_USAGE_RINGTONE, 101); + ASSERT_EQ(ret.size(), 1u); + ASSERT_NE(ret[0], nullptr); + ret = router.GetRingRenderDevices(STREAM_USAGE_VOICE_RINGTONE, 102); + ASSERT_EQ(ret.size(), 1u); + ASSERT_NE(ret[0], nullptr); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/domain/router/test/unittest/stream_filter_router_unit_test/include/stream_filter_router_ext_unit_test.h b/services/audio_policy/server/domain/router/test/unittest/stream_filter_router_unit_test/include/stream_filter_router_ext_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..bdbca8dffcf30e5647673adc5f11b72bd80b0228 --- /dev/null +++ b/services/audio_policy/server/domain/router/test/unittest/stream_filter_router_unit_test/include/stream_filter_router_ext_unit_test.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef STREAM_FILTER_ROUTER_EXT_UNIT_TEST_H +#define STREAM_FILTER_ROUTER_EXT_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_policy_service.h" +#include "audio_policy_server.h" +#include "stream_filter_router.h" + +namespace OHOS { +namespace AudioStandard { + +class StreamFilterRouterExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); + +private: + std::shared_ptr streamFilterRouter_ = nullptr; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // STREAM_FILTER_ROUTER_EXT_UNIT_TEST_H diff --git a/services/audio_policy/server/domain/router/test/unittest/stream_filter_router_unit_test/src/stream_filter_router_ext_unit_test.cpp b/services/audio_policy/server/domain/router/test/unittest/stream_filter_router_unit_test/src/stream_filter_router_ext_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cd89399d9e74fd682f33472901f60e53385bd09a --- /dev/null +++ b/services/audio_policy/server/domain/router/test/unittest/stream_filter_router_unit_test/src/stream_filter_router_ext_unit_test.cpp @@ -0,0 +1,421 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "stream_filter_router_ext_unit_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { +void StreamFilterRouterExtUnitTest::SetUpTestCase(void) {} +void StreamFilterRouterExtUnitTest::TearDownTestCase(void) {} + +void StreamFilterRouterExtUnitTest::SetUp(void) +{ + streamFilterRouter_ = std::make_shared(); +} + +void StreamFilterRouterExtUnitTest::TearDown(void) +{ + streamFilterRouter_ = nullptr; +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetMediaRenderDevice_001 + * @tc.desc : Test GetMediaRenderDevice type == CAST_TYPE_NULL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetMediaRenderDevice_001, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_NULL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetMediaRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetMediaRenderDevice_002 + * @tc.desc : Test GetMediaRenderDevice type == CAST_TYPE_ALL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetMediaRenderDevice_002, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_ALL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetMediaRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetMediaRenderDevice_003 + * @tc.desc : Test GetMediaRenderDevice type == CAST_TYPE_PROJECTION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetMediaRenderDevice_003, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_PROJECTION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + AudioDeviceManager::GetAudioDeviceManager().remoteRenderDevices_.clear(); + vector> descriptors; + EXPECT_FALSE(streamFilterRouter_->IsIncomingDeviceInRemoteDevice(descriptors, descriptor)); + EXPECT_NE(streamFilterRouter_->GetMediaRenderDevice(streamUsage, clientUID), nullptr); + + AudioDeviceManager::GetAudioDeviceManager().remoteRenderDevices_.push_back(descriptor); + streamUsage = STREAM_USAGE_MUSIC; + descriptors.push_back(descriptor); + EXPECT_TRUE(streamFilterRouter_->IsIncomingDeviceInRemoteDevice(descriptors, descriptor)); + EXPECT_NE(streamFilterRouter_->GetMediaRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetMediaRenderDevice_004 + * @tc.desc : Test GetMediaRenderDevice type == CAST_TYPE_COOPERATION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetMediaRenderDevice_004, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_COOPERATION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetMediaRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallRenderDevice_001 + * @tc.desc : Test GetCallRenderDevice type == CAST_TYPE_NULL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallRenderDevice_001, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_NULL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallRenderDevice_002 + * @tc.desc : Test GetCallRenderDevice type == CAST_TYPE_ALL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallRenderDevice_002, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_ALL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + AudioDeviceManager::GetAudioDeviceManager().remoteRenderDevices_.push_back(descriptor); + int32_t clientUID = 1; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + EXPECT_NE(streamFilterRouter_->GetCallRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallRenderDevice_003 + * @tc.desc : Test GetCallRenderDevice type == CAST_TYPE_PROJECTION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallRenderDevice_003, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_PROJECTION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallRenderDevice_004 + * @tc.desc : Test GetCallRenderDevice type == CAST_TYPE_COOPERATION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallRenderDevice_004, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_COOPERATION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + StreamUsage streamUsage = STREAM_USAGE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallRenderDevice(streamUsage, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallCaptureDevice_001 + * @tc.desc : Test GetCallCaptureDevice type == CAST_TYPE_NULL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallCaptureDevice_001, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_NULL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallCaptureDevice(sourceType, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallCaptureDevice_002 + * @tc.desc : Test GetCallCaptureDevice type == CAST_TYPE_ALL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallCaptureDevice_002, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_ALL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + AudioDeviceManager::GetAudioDeviceManager().remoteRenderDevices_.push_back(descriptor); + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallCaptureDevice(sourceType, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallCaptureDevice_003 + * @tc.desc : Test GetCallCaptureDevice type == CAST_TYPE_PROJECTION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallCaptureDevice_003, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_PROJECTION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallCaptureDevice(sourceType, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetCallCaptureDevice_004 + * @tc.desc : Test GetCallCaptureDevice type == CAST_TYPE_COOPERATION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetCallCaptureDevice_004, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_COOPERATION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + EXPECT_NE(streamFilterRouter_->GetCallCaptureDevice(sourceType, clientUID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetRecordCaptureDevice_001 + * @tc.desc : Test GetRecordCaptureDevice type == CAST_TYPE_NULL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetRecordCaptureDevice_001, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_NULL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + uint32_t sessionID = 1; + EXPECT_NE(streamFilterRouter_->GetRecordCaptureDevice(sourceType, clientUID, sessionID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetRecordCaptureDevice_002 + * @tc.desc : Test GetRecordCaptureDevice type == CAST_TYPE_ALL. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetRecordCaptureDevice_002, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_ALL + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + uint32_t sessionID = 1; + EXPECT_NE(streamFilterRouter_->GetRecordCaptureDevice(sourceType, clientUID, sessionID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetRecordCaptureDevice_003 + * @tc.desc : Test GetRecordCaptureDevice type == CAST_TYPE_PROJECTION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetRecordCaptureDevice_003, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + descriptor->deviceRole_ = INPUT_DEVICE; + descriptor->deviceType_ = DEVICE_TYPE_MIC; + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_PROJECTION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + uint32_t sessionID = 1; + AudioDeviceManager::GetAudioDeviceManager().remoteRenderDevices_.clear(); + EXPECT_NE(streamFilterRouter_->GetRecordCaptureDevice(sourceType, clientUID, sessionID), nullptr); + + AudioDeviceManager::GetAudioDeviceManager().remoteRenderDevices_.push_back(descriptor); + sourceType = SOURCE_TYPE_MIC; + EXPECT_NE(streamFilterRouter_->GetRecordCaptureDevice(sourceType, clientUID, sessionID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: GetRecordCaptureDevice_004 + * @tc.desc : Test GetRecordCaptureDevice type == CAST_TYPE_COOPERATION. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, GetRecordCaptureDevice_004, TestSize.Level4) +{ + auto descriptor = std::make_shared(); + DistributedRoutingInfo distributedRoutingInfo = { + .descriptor = descriptor, + .type = CAST_TYPE_COOPERATION + }; + AudioPolicyService::GetAudioPolicyService().distributedRoutingInfo_ = distributedRoutingInfo; + SourceType sourceType = SOURCE_TYPE_INVALID; + int32_t clientUID = 1; + uint32_t sessionID = 1; + EXPECT_NE(streamFilterRouter_->GetRecordCaptureDevice(sourceType, clientUID, sessionID), nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: IsIncomingDeviceInRemoteDevice_001 + * @tc.desc : Test IsIncomingDeviceInRemoteDevice desc == nullptr. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, IsIncomingDeviceInRemoteDevice_001, TestSize.Level4) +{ + vector> descriptors; + std::shared_ptr incomingDevice = nullptr; + descriptors.push_back(incomingDevice); + bool ret = streamFilterRouter_->IsIncomingDeviceInRemoteDevice(descriptors, incomingDevice); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: IsIncomingDeviceInRemoteDevice_002 + * @tc.desc : Test IsIncomingDeviceInRemoteDevice desc != nullptr. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, IsIncomingDeviceInRemoteDevice_002, TestSize.Level4) +{ + vector> descriptors; + auto incomingDevice = std::make_shared(); + auto descriptor1 = std::make_shared(incomingDevice); + descriptor1->deviceRole_ = INPUT_DEVICE; + auto descriptor2 = std::make_shared(incomingDevice); + descriptor2->deviceType_ = DEVICE_TYPE_INVALID; + auto descriptor3 = std::make_shared(incomingDevice); + descriptor3->interruptGroupId_ = 1; + auto descriptor4 = std::make_shared(incomingDevice); + descriptor4->volumeGroupId_ = 1; + auto descriptor5 = std::make_shared(incomingDevice); + descriptor5->networkId_ = "testNetworkId"; + auto descriptor6 = std::make_shared(incomingDevice); + descriptor6->macAddress_ = "00:11:22:33:44:55"; + descriptors = { descriptor1, descriptor2, descriptor3, descriptor4, descriptor5, descriptor6 }; + bool ret = streamFilterRouter_->IsIncomingDeviceInRemoteDevice(descriptors, incomingDevice); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: SelectRemoteCaptureDevice_001 + * @tc.desc : Test SelectRemoteCaptureDevice descriptor == nullptr. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, SelectRemoteCaptureDevice_001, TestSize.Level4) +{ + vector> descriptors; + std::shared_ptr incomingDevice = nullptr; + descriptors.push_back(incomingDevice); + bool hasDescriptor = false; + auto descriptorPtr = streamFilterRouter_->SelectRemoteCaptureDevice(descriptors, incomingDevice, hasDescriptor); + EXPECT_NE(descriptorPtr, nullptr); +} + +/** + * @tc.name : Test StreamFilterRouter. + * @tc.number: SelectRemoteCaptureDevice_002 + * @tc.desc : Test SelectRemoteCaptureDevice descriptor != nullptr. + */ +HWTEST_F(StreamFilterRouterExtUnitTest, SelectRemoteCaptureDevice_002, TestSize.Level4) +{ + vector> descriptors; + auto incomingDevice = std::make_shared(); + auto descriptor1 = std::make_shared(incomingDevice); + descriptor1->networkId_ = "testNetworkId"; + auto descriptor2 = std::make_shared(incomingDevice); + descriptor2->deviceRole_ = INPUT_DEVICE; + auto descriptor3 = std::make_shared(incomingDevice); + descriptor3->deviceType_ = DEVICE_TYPE_MIC; + descriptors = { descriptor1, descriptor2, descriptor3 }; + bool hasDescriptor = false; + auto descriptorPtr = streamFilterRouter_->SelectRemoteCaptureDevice(descriptors, incomingDevice, hasDescriptor); + EXPECT_NE(descriptorPtr, nullptr); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/domain/session/test/BUILD.gn b/services/audio_policy/server/domain/session/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..31e48eab72cfc434f8e6fe9b4e0be3e6e8ac7800 --- /dev/null +++ b/services/audio_policy/server/domain/session/test/BUILD.gn @@ -0,0 +1,77 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../../accessibility.gni") +import("../../../../../../appgallery.gni") +import("../../../../../../bluetooth_part.gni") +import("../../../../../../config.gni") + +audio_framework_root = "../../../../../../" + +group("audio_policy_session_unit_test") { + testonly = true + deps = [ + ":audio_session_new_unit_test", + ] +} + +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +ohos_unittest("audio_session_new_unit_test") { + module_out_path = module_output_path + + include_dirs = [ "./unittest/audio_session_new_unit_test/include" ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + sanitize = { + cfi = true + cfi_cross_dso = true + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = true + } + + external_deps = [ + "bluetooth:btframework", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "googletest:gmock", + "hilog:libhilog", + "init:libbegetutil", + "kv_store:distributeddata_inner", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + "eventhandler:libeventhandler", + ] + + sources = + [ "./unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp" ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../../../../audio_policy:audio_policy_service_static", + ] +} \ No newline at end of file diff --git a/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..92a99d2f4c0c9390b4438fe7bda6e7a8ff9a8ef8 --- /dev/null +++ b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_SESSION_NEW_UNIT_TEST_H +#define AUDIO_SESSION_NEW_UNIT_TEST_H +#include "gtest/gtest.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioSessionNewUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_SESSION_NEW_UNIT_TEST_H diff --git a/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d9b697098c28beec99cbbacbbb6ce9ee8b119f83 --- /dev/null +++ b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp @@ -0,0 +1,289 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "audio_errors.h" +#include "audio_session.h" +#include "audio_session_service.h" +#include "audio_session_new_unit_test.h" +#include "audio_pipe_manager.h" +#include "audio_device_manager.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void AudioSessionNewUnitTest::SetUpTestCase(void) {} +void AudioSessionNewUnitTest::TearDownTestCase(void) {} +void AudioSessionNewUnitTest::SetUp(void) {} +void AudioSessionNewUnitTest::TearDown(void) {} + +/** +* @tc.name : Test SetAudioSessionScene +* @tc.number: AudioSessionNewUnitTest_SetAudioSessionScene_001 +* @tc.desc : Test SetAudioSessionScene function +*/ +HWTEST_F(AudioSessionNewUnitTest, SetAudioSessionScene_001, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + AudioSessionScene scene = AudioSessionScene::GAME; + int32_t ret = audioSession->SetAudioSessionScene(scene); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test SetAudioSessionScene +* @tc.number: AudioSessionNewUnitTest_SetAudioSessionScene_002 +* @tc.desc : Test SetAudioSessionScene function +*/ +HWTEST_F(AudioSessionNewUnitTest, SetAudioSessionScene_002, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + AudioSessionScene scene = AudioSessionScene::VOICE_COMMUNICATION; + int32_t ret = audioSession->SetAudioSessionScene(scene); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionNewUnitTest_AddStreamInfo_001. +* @tc.desc : Test AddStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, AddStreamInfo_001, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = nullptr; + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + AudioInterrupt audioInterrupt = {}; + audioInterrupt.streamId = 1; + audioSession->state_ = AudioSessionState::SESSION_ACTIVE; + audioSession->audioSessionScene_ = AudioSessionScene::GAME; + audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC; + audioSession->AddStreamInfo(audioInterrupt); + EXPECT_TRUE(audioSession->IsAudioSessionEmpty()); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionNewUnitTest_AddStreamInfo_002. +* @tc.desc : Test AddStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, AddStreamInfo_002, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = nullptr; + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + AudioInterrupt audioInterrupt = {}; + audioInterrupt.streamId = 1; + audioSession->state_ = AudioSessionState::SESSION_ACTIVE; + audioSession->defaultDeviceType_ = DEVICE_TYPE_SPEAKER; + audioSession->audioSessionScene_ = AudioSessionScene::MEDIA; + audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID; + audioSession->AddStreamInfo(audioInterrupt); + EXPECT_FALSE(audioSession->IsAudioSessionEmpty()); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionUnitTest_RemoveStreamInfo_001. +* @tc.desc : Test RemoveStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, RemoveStreamInfo_001, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = nullptr; + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + AudioInterrupt audioInterrupt = {}; + audioInterrupt.streamId = 1; + audioSession->AddStreamInfo(audioInterrupt); + audioSession->state_ = AudioSessionState::SESSION_ACTIVE; + audioSession->defaultDeviceType_ = DEVICE_TYPE_SPEAKER; + audioSession->RemoveStreamInfo(audioInterrupt.streamId); + EXPECT_TRUE(audioSession->IsAudioSessionEmpty()); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionUnitTest_UpdateSingleVoipStreamDefaultOutputDevice_001. +* @tc.desc : Test RemoveStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, UpdateSingleVoipStreamDefaultOutputDevice_001, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = nullptr; + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + AudioInterrupt audioInterrupt = {}; + audioInterrupt.streamId = 1; + audioInterrupt.streamUsage = STREAM_USAGE_MUSIC; + audioSession->streamsInSession_.push_back(audioInterrupt); + audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA); + int32_t ret = audioSession->Activate(strategy); + EXPECT_EQ(ret, SUCCESS); + audioSession->UpdateSingleVoipStreamDefaultOutputDevice(audioInterrupt); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionUnitTest_EnableSingleVoipStreamDefaultOutputDevice_001. +* @tc.desc : Test RemoveStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_001, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA)); + + AudioInterrupt interrupt = {}; + interrupt.streamUsage = STREAM_USAGE_MUSIC; + interrupt.streamId = 2; + audioSession->pipeManager_ = nullptr; + + int32_t ret = audioSession->EnableSingleVoipStreamDefaultOutputDevice(interrupt); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionUnitTest_EnableSingleVoipStreamDefaultOutputDevice_002. +* @tc.desc : Test RemoveStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_002, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA)); + + AudioInterrupt interrupt = {}; + interrupt.streamUsage = STREAM_USAGE_VOICE_MESSAGE; + interrupt.streamId = 2; + audioSession->pipeManager_ = nullptr; + + int32_t ret = audioSession->EnableSingleVoipStreamDefaultOutputDevice(interrupt); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test AudioSession. +* @tc.number: AudioSessionUnitTest_EnableSingleVoipStreamDefaultOutputDevice_003. +* @tc.desc : Test RemoveStreamInfo. +*/ +HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_003, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA)); + + AudioInterrupt interrupt = {}; + interrupt.streamUsage = STREAM_USAGE_MUSIC; + interrupt.streamId = 2; + + int32_t ret = audioSession->EnableSingleVoipStreamDefaultOutputDevice(interrupt); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test EnableSingleVoipStreamDefaultOutputDevice: enter SetDefaultOutputDevice via real data. + * @tc.number: AudioSessionNewUnitTest_EnableSingleVoipStreamDefaultOutputDevice_004. + * @tc.desc : Test that function enters SetDefaultOutputDevice by injecting real stream descriptor. + */ +HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_004, TestSize.Level4) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA)); + + AudioInterrupt interrupt = {}; + interrupt.streamUsage = STREAM_USAGE_VOICE_MESSAGE; + interrupt.streamId = 2; + + auto streamDesc = std::make_shared(); + streamDesc->sessionId_ = 2; + streamDesc->rendererInfo_.streamUsage = STREAM_USAGE_VOICE_MESSAGE; + streamDesc->streamStatus_ = STREAM_STATUS_STARTED; + + auto pipeInfo = std::make_shared(); + pipeInfo->id_ = 1; + pipeInfo->name_ = "TestOutputPipe"; + pipeInfo->pipeRole_ = PIPE_ROLE_OUTPUT; + pipeInfo->InitAudioStreamInfo(); + + pipeInfo->streamDescriptors_.push_back(streamDesc); + + auto pipeManager = AudioPipeManager::GetPipeManager(); + pipeManager->AddAudioPipeInfo(pipeInfo); + + int32_t ret = audioSession->EnableSingleVoipStreamDefaultOutputDevice(interrupt); + EXPECT_EQ(ret, SUCCESS); + pipeManager->curPipeList_.clear(); +} + +/** +* @tc.name : Test IsRecommendToStopAudio. +* @tc.number: AudioSessionUnitTest_IsRecommendToStopAudio_001. +* @tc.desc : Test IsRecommendToStopAudio function. +*/ +HWTEST_F(AudioSessionNewUnitTest, IsRecommendToStopAudio_001, TestSize.Level1) +{ + int32_t callerPid = 1; + AudioSessionStrategy strategy; + std::shared_ptr audioSessionStateMonitor = std::make_shared(); + auto audioSession = std::make_shared(callerPid, strategy, audioSessionStateMonitor); + + auto validDescriptor = std::make_shared(); + + EXPECT_FALSE(audioSession->IsRecommendToStopAudio(nullptr)); + + auto eventContextObj = std::make_shared(); + + eventContextObj->reason_ = AudioStreamDeviceChangeReason::OVERRODE; + eventContextObj->descriptor = validDescriptor; + EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj)); + + eventContextObj->reason_ = AudioStreamDeviceChangeReason::UNKNOWN; + eventContextObj->descriptor = nullptr; + EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj)); + + eventContextObj->reason_ = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE; + eventContextObj->descriptor = validDescriptor; + EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj)); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/domain/stream/audio_stream_collector.cpp b/services/audio_policy/server/domain/stream/audio_stream_collector.cpp index 3b81960890b2dde0a54979b3f6e2281ee13e4349..45b35e52a93d50580f82891a5d9b23df3cbee714 100644 --- a/services/audio_policy/server/domain/stream/audio_stream_collector.cpp +++ b/services/audio_policy/server/domain/stream/audio_stream_collector.cpp @@ -1246,6 +1246,13 @@ bool AudioStreamCollector::IsStreamActive(AudioStreamType volumeType) } AudioVolumeType rendererVolumeType = GetVolumeTypeFromContentUsage((changeInfo->rendererInfo).contentType, (changeInfo->rendererInfo).streamUsage); + if (rendererVolumeType == STREAM_VOICE_ASSISTANT) { + if (!CheckoutSystemAppUtil::CheckoutSystemApp(changeInfo->clientUID)) { + AUDIO_INFO_LOG("matched clientUid: %{public}d id: %{public}d", + changeInfo->clientUID, changeInfo->sessionId); + rendererVolumeType = STREAM_MUSIC; + } + } if (rendererVolumeType == volumeType) { // An active stream has been found, return true directly. AUDIO_INFO_LOG("matched clientUid: %{public}d id: %{public}d", @@ -1453,9 +1460,10 @@ int32_t AudioStreamCollector::UpdateCapturerInfoMuteStatus(int32_t uid, bool mut return SUCCESS; } -std::map, ConcurrencyAction>& AudioStreamCollector::GetConcurrencyMap() +ConcurrencyAction AudioStreamCollector::GetConcurrencyAction( + const AudioPipeType existingPipe, const AudioPipeType commingPipe) { - return audioConcurrencyService_->GetConcurrencyMap(); + return audioConcurrencyService_->GetConcurrencyAction(existingPipe, commingPipe); } void AudioStreamCollector::WriterStreamChangeSysEvent(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) diff --git a/services/audio_policy/server/domain/stream/audio_stream_collector.h b/services/audio_policy/server/domain/stream/audio_stream_collector.h index 87e59255bcd7504a5b327eee5172f62cb23d9e4a..1713886c13f97adfbf20b65711089bedcdd157ca 100644 --- a/services/audio_policy/server/domain/stream/audio_stream_collector.h +++ b/services/audio_policy/server/domain/stream/audio_stream_collector.h @@ -81,7 +81,7 @@ public: bool ExistStreamForPipe(AudioPipeType pipeType); int32_t GetRendererDeviceInfo(const int32_t sessionId, AudioDeviceDescriptor &outputDeviceInfo); - std::map, ConcurrencyAction>& GetConcurrencyMap(); + ConcurrencyAction GetConcurrencyAction(const AudioPipeType existingPipe, const AudioPipeType commingPipe); void ResetRendererStreamDeviceInfo(const AudioDeviceDescriptor& updatedDesc); void ResetCapturerStreamDeviceInfo(const AudioDeviceDescriptor& updatedDesc); StreamUsage GetRunningStreamUsageNoUltrasonic(); diff --git a/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h b/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h index 2836472bc274b0784e4f9f153f08c2482f3336c2..d2d9f8b63ab5caffc337a28635feb85f583058ae 100644 --- a/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h +++ b/services/audio_policy/server/domain/volume/include/audio_adapter_manager.h @@ -305,12 +305,12 @@ public: void RegisterDoNotDisturbStatusWhiteList(); int32_t SetQueryDeviceVolumeBehaviorCallback(const sptr &object); void HandleDistributedDeviceVolume(); - void SetSleVoiceStatusFlag(bool isSleVoiceStatus); int32_t SetSystemVolumeDegree(AudioStreamType streamType, int32_t volumeDegree); int32_t GetSystemVolumeDegree(AudioStreamType streamType); int32_t GetMinVolumeDegree(AudioVolumeType volumeType); + void SendLoudVolumeModeToDsp(FunctionHoldType funcHoldType, bool state); private: friend class PolicyCallbackImpl; @@ -414,6 +414,7 @@ private: static void UpdateSinkArgs(const AudioModuleInfo &audioModuleInfo, std::string &args); void UpdateVolumeForLowLatency(); bool IsDistributedVolumeType(AudioStreamType streamType); + void GetHdiSourceTypeToAudioSourceAttr(IAudioSourceAttr &attr, int32_t sourceType) const; template std::vector TransferTypeToByteArray(const T &t) diff --git a/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h b/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h index e01cc7afc809cb3afcdc05416d70c494e66b8233..bca4787666f7b470da3ba2443184d4c8e896839f 100644 --- a/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h +++ b/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification.h @@ -51,6 +51,24 @@ public: }; typedef AudioSafeVolumeNotification* CreateSafeVolumeNotification(); + +const int32_t LOUD_ICON_WIDTH = 24; +const int32_t LOUD_ICON_HEIGHT = 24; + +const std::string LOUD_VOLUME_ICON_ID = "loud_volume_notification_icon"; +const std::string LOUD_VOLUME_FEATURE_TITTLE_ID = "notification_feature_loud_volume_tittle"; +const std::string LOUD_VOLUME_ENABLE_TITTLE_ID = "notification_enable_loud_volume_tittle"; + +class AudioLoudVolumeNotification { +public: + AudioLoudVolumeNotification() = default; + virtual ~AudioLoudVolumeNotification() = default; + + virtual void PublishLoudVolumeNotification(int32_t notificationId) = 0; +}; + +typedef AudioLoudVolumeNotification* CreateLoudVolumeNotification(); + } // namespace AudioStandard } // namespace OHOS #endif // AUDIO_SAFE_VOLUME_NOTIFICATION_H diff --git a/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification_impl.h b/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification_impl.h index 2348803d2fe14c42ba142f44f7a7f6b9f465e5e1..46c68a617e6512231bbfee8b02d03fda4dc19a62 100644 --- a/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification_impl.h +++ b/services/audio_policy/server/domain/volume/include/audio_safe_volume_notification_impl.h @@ -58,6 +58,34 @@ extern "C" AudioSafeVolumeNotification *CreateSafeVolumeNotificationImpl() { return new AudioSafeVolumeNotificationImpl; } + +class AudioLoudVolumeNotificationImpl : public AudioLoudVolumeNotification { +public: + AudioLoudVolumeNotificationImpl() = default; + virtual ~AudioLoudVolumeNotificationImpl() = default; + + void PublishLoudVolumeNotification(int32_t notificationId) override; +private: + std::string GetSystemStringByName(const std::string &name); + bool SetTitleAndText(int32_t notificationId, Notification::NotificationCapsule &capsule); + bool GetPixelMap(); + Global::Resource::RState GetMediaDataByName(const std::string& name, size_t& len, + std::unique_ptr& outValue, uint32_t density = 0); + + std::string title_ {}; + std::string text_ {}; + std::string buttonName_ {}; + std::string iconPath_ {}; + + std::mutex mutex_ {}; + std::shared_ptr iconPixelMap_ {}; +}; + +extern "C" AudioLoudVolumeNotification *CreateLoudVolumeNotificationImpl() +{ + return new AudioLoudVolumeNotificationImpl; +} + } // namespace AudioStandard } // namespace OHOS #endif // AUDIO_SAFE_VOLUME_NOTIFICATION_IMPL_H diff --git a/services/audio_policy/server/domain/volume/include/audio_volume_manager.h b/services/audio_policy/server/domain/volume/include/audio_volume_manager.h index f05e5d57ba1fed9c9ebb8137f9499dcfc407417c..b4fe7656ae8a58dcc998bfacc751c90a4d1204ce 100644 --- a/services/audio_policy/server/domain/volume/include/audio_volume_manager.h +++ b/services/audio_policy/server/domain/volume/include/audio_volume_manager.h @@ -141,6 +141,7 @@ public: int32_t zoneId); int32_t GetSystemVolumeDegree(AudioStreamType streamType); int32_t GetMinVolumeDegree(AudioVolumeType volumeType) const; + void SendLoudVolumeMode(FunctionHoldType funcHoldType, bool state, bool repeatTrigNotif = false); private: AudioVolumeManager() : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), @@ -167,6 +168,7 @@ private: DeviceType deviceType = DEVICE_TYPE_NONE); void PublishSafeVolumeNotification(int32_t notificationId); void CancelSafeVolumeNotification(int32_t notificationId); + void PublishLoudVolumeNotification(int32_t notificationId); bool IsWiredHeadSet(const DeviceType &deviceType); void CheckToCloseNotification(AudioStreamType streamType, int32_t volumeLevel); bool DeviceIsSupportSafeVolume(); diff --git a/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h b/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h index 2dc331e8367bd123f8c8ab3857bc8f169c09d0e8..d697e21806bdf59591ab3d78c540dcd3e0f86394 100644 --- a/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h +++ b/services/audio_policy/server/domain/volume/include/iaudio_policy_interface.h @@ -252,6 +252,7 @@ public: virtual int32_t SetSystemVolumeDegree(AudioStreamType streamType, int32_t volumeDegree) = 0; virtual int32_t GetSystemVolumeDegree(AudioStreamType streamType) = 0; virtual int32_t GetMinVolumeDegree(AudioVolumeType volumeType) = 0; + virtual void SendLoudVolumeModeToDsp(FunctionHoldType funcHoldType, bool state) = 0; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp b/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp index 4f8d4c3439703c7658cf66f5202b9249935b9864..17bfe1d5ceeb2c41477dd36f918730412cb407a8 100644 --- a/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp +++ b/services/audio_policy/server/domain/volume/src/audio_adapter_manager.cpp @@ -415,6 +415,28 @@ void AudioAdapterManager::UpdateSafeVolumeByS4() SetVolumeDb(STREAM_MUSIC); } +void AudioAdapterManager::SendLoudVolumeModeToDsp(FunctionHoldType funcHoldType, bool state) +{ + std::string key = "LOUD_VOLUME_MODE"; + std::string value = "super_loudness_mode=voice_off"; + std::string identity = IPCSkeleton::ResetCallingIdentity(); + CHECK_AND_RETURN_LOG(audioServerProxy_ != nullptr, "audioServerProxy_ null"); + + if (FUNCTION_HOLD_SYSTEM == funcHoldType) { + value = state ? "super_loudness_mode=voice_on" : "super_loudness_mode=voice_off"; + } else if (FUNCTION_HOLD_MUSIC == funcHoldType) { + value = state ? "super_loudness_mode=music_on" : "super_loudness_mode=music_off"; + } else { + AUDIO_ERR_LOG("funcHoldType error : %{public}d", funcHoldType); + return; + } + + audioServerProxy_->SetAudioParameter(key, value); + IPCSkeleton::SetCallingIdentity(identity); + AUDIO_INFO_LOG("update LoudVolume [%{public}s]", value.c_str()); + return; +} + int32_t AudioAdapterManager::SetAppVolumeLevel(int32_t appUid, int32_t volumeLevel) { AUDIO_INFO_LOG("SetSystemVolumeLevel: appUid: %{public}d, deviceType: %{public}d, volumeLevel:%{public}d", @@ -1538,6 +1560,9 @@ void AudioAdapterManager::GetSourceIdInfoAndIdType( idInfo = HDI_ID_INFO_VOIP; } } + if (pipeInfo->routeFlag_ & AUDIO_INPUT_FLAG_AI) { + idType = HDI_ID_TYPE_AI; + } } } @@ -1997,6 +2022,19 @@ IAudioSinkAttr AudioAdapterManager::GetAudioSinkAttr(const AudioModuleInfo &audi return attr; } +void AudioAdapterManager::GetHdiSourceTypeToAudioSourceAttr(IAudioSourceAttr &attr, int32_t sourceType) const +{ + auto sourceStrategyMapget = AudioSourceStrategyData::GetInstance().GetSourceStrategyMap(); + if (sourceStrategyMapget == nullptr) { + return; + } + auto sampIt = sourceStrategyMapget->find((SourceType)sourceType); + if (sampIt == sourceStrategyMapget->end()) { + return; + } + attr.hdiSourceType = sampIt->second.hdiSource; +} + IAudioSourceAttr AudioAdapterManager::GetAudioSourceAttr(const AudioModuleInfo &audioModuleInfo) const { IAudioSourceAttr attr; @@ -2038,6 +2076,7 @@ IAudioSourceAttr AudioAdapterManager::GetAudioSourceAttr(const AudioModuleInfo & attr.channelEc = static_cast(std::stoul(audioModuleInfo.ecChannels)); } } + GetHdiSourceTypeToAudioSourceAttr(attr, attr.sourceType); return attr; } diff --git a/services/audio_policy/server/domain/volume/src/audio_safe_volume_notification_impl.cpp b/services/audio_policy/server/domain/volume/src/audio_safe_volume_notification_impl.cpp index 219eb0b1a98c6e2650afcb8ba4b18825981780c1..6e71918c0f0f85bac502f2f74bbcabe6a77ca9f7 100644 --- a/services/audio_policy/server/domain/volume/src/audio_safe_volume_notification_impl.cpp +++ b/services/audio_policy/server/domain/volume/src/audio_safe_volume_notification_impl.cpp @@ -248,5 +248,107 @@ Global::Resource::RState AudioSafeVolumeNotificationImpl::GetMediaDataByName(con IPCSkeleton::SetCallingIdentity(identity); return rstate; } + +std::string AudioLoudVolumeNotificationImpl::GetSystemStringByName(const std::string &name) +{ + std::string identity = IPCSkeleton::ResetCallingIdentity(); + std::string result = ResourceManagerAdapter::GetInstance()->GetSystemStringByName(name); + IPCSkeleton::SetCallingIdentity(identity); + return result; +} + +bool AudioLoudVolumeNotificationImpl::SetTitleAndText(int32_t notificationId, + Notification::NotificationCapsule &capsule) +{ + capsule.SetTitle(GetSystemStringByName(LOUD_VOLUME_FEATURE_TITTLE_ID)); + capsule.SetContent(GetSystemStringByName(LOUD_VOLUME_ENABLE_TITTLE_ID)); + + return true; +} + +bool AudioLoudVolumeNotificationImpl::GetPixelMap() +{ + if (iconPixelMap_ != nullptr) { + AUDIO_ERR_LOG("icon pixel map already exists."); + return false; + } + + std::unique_ptr resourceData; + size_t resourceDataLength = 0; + auto ret = GetMediaDataByName(LOUD_VOLUME_ICON_ID.c_str(), resourceDataLength, resourceData); + if (ret != Global::Resource::RState::SUCCESS) { + AUDIO_ERR_LOG("get (%{public}s) failed, errorCode:%{public}d", LOUD_VOLUME_ICON_ID.c_str(), + static_cast(ret)); + return false; + } + + Media::SourceOptions opts; + uint32_t errorCode = 0; + std::unique_ptr imageSource = + Media::ImageSource::CreateImageSource(resourceData.get(), resourceDataLength, opts, errorCode); + Media::DecodeOptions decodeOpts; + decodeOpts.desiredSize = {LOUD_ICON_WIDTH, LOUD_ICON_HEIGHT}; + decodeOpts.desiredPixelFormat = Media::PixelFormat::BGRA_8888; + if (imageSource) { + AUDIO_INFO_LOG("GetPixelMap SUCCESS."); + std::unique_ptr pixelMap = imageSource->CreatePixelMap(decodeOpts, errorCode); + iconPixelMap_ = std::move(pixelMap); + } + if (errorCode != 0 || (iconPixelMap_ == nullptr)) { + AUDIO_ERR_LOG("get badge failed, errorCode:%{public}u", errorCode); + return false; + } + return true; +} + +void AudioLoudVolumeNotificationImpl::PublishLoudVolumeNotification(int32_t notificationId) +{ + const int TYPE_CODE = 16; + std::shared_ptr instantlLiveViewContent = + std::make_shared(); + if (instantlLiveViewContent == nullptr) { + AUDIO_ERR_LOG("instantlLiveViewContent is null"); + return; + } + + Notification::NotificationCapsule capsule; + if (!SetTitleAndText(notificationId, capsule)) { + AUDIO_ERR_LOG("error setting title and text"); + return; + } + GetPixelMap(); + if (iconPixelMap_ != nullptr) { + capsule.SetIcon(iconPixelMap_); + } + instantlLiveViewContent->SetCapsule(capsule); + instantlLiveViewContent->addFlag(Notification::NotificationLocalLiveViewContent::LiveViewContentInner::CAPSULE); + + instantlLiveViewContent->SetType(TYPE_CODE); + instantlLiveViewContent->SetLiveViewType( + Notification::NotificationLocalLiveViewContent::LiveViewTypes::LIVE_VIEW_INSTANT); + + std::shared_ptr instantContent = + std::make_shared(instantlLiveViewContent); + + Notification::NotificationRequest instantRequest; + instantRequest.SetNotificationId(notificationId); + instantRequest.SetCreatorUid(getuid()); + instantRequest.SetContent(instantContent); + instantRequest.SetSlotType(Notification::NotificationConstant::SlotType::LIVE_VIEW); + + int32_t result = Notification::NotificationHelper::PublishNotification(instantRequest); + AUDIO_INFO_LOG("AudioPolicyServer publish result:%{public}d", result); + return; +} + +Global::Resource::RState AudioLoudVolumeNotificationImpl::GetMediaDataByName(const std::string& name, size_t& len, + std::unique_ptr& outValue, uint32_t density) +{ + std::string identity = IPCSkeleton::ResetCallingIdentity(); + Global::Resource::RState rstate = + ResourceManagerAdapter::GetInstance()->GetMediaDataByName(name, len, outValue, density); + IPCSkeleton::SetCallingIdentity(identity); + return rstate; +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp b/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp index ad94be2ebf4e5578be5ffa2ece78454e97f116e2..a45b685d0cad4fa317ee2e2da876e8612948bf93 100644 --- a/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp +++ b/services/audio_policy/server/domain/volume/src/audio_volume_manager.cpp @@ -317,6 +317,46 @@ bool AudioVolumeManager::DeviceIsSupportSafeVolume() } } +void AudioVolumeManager::PublishLoudVolumeNotification(int32_t notificationId) +{ + void *libHandle = dlopen("libaudio_safe_volume_notification_impl.z.so", RTLD_LAZY); + if (libHandle == nullptr) { + AUDIO_ERR_LOG("dlopen failed %{public}s", __func__); + return; + } + CreateLoudVolumeNotification *createLoudVolumeNotificationImpl = + reinterpret_cast(dlsym(libHandle, "CreateLoudVolumeNotificationImpl")); + if (createLoudVolumeNotificationImpl == nullptr) { + AUDIO_ERR_LOG("createLoudVolumeNotificationImpl failed %{public}s", __func__); +#ifndef TEST_COVERAGE + dlclose(libHandle); +#endif + return; + } + AudioLoudVolumeNotification *audioLoudVolumeNotificationImpl = createLoudVolumeNotificationImpl(); + if (audioLoudVolumeNotificationImpl == nullptr) { + AUDIO_ERR_LOG("audioLoudVolumeNotificationImpl is nullptr %{public}s", __func__); +#ifndef TEST_COVERAGE + dlclose(libHandle); +#endif + return; + } + audioLoudVolumeNotificationImpl->PublishLoudVolumeNotification(notificationId); + delete audioLoudVolumeNotificationImpl; +#ifndef TEST_COVERAGE + dlclose(libHandle); +#endif +} + +void AudioVolumeManager::SendLoudVolumeMode(FunctionHoldType funcHoldType, bool state, bool repeatTrigNotif) +{ + if (state && repeatTrigNotif) { + const int INSTANT_NOTIFICATION_ID = 6; + PublishLoudVolumeNotification(INSTANT_NOTIFICATION_ID); + } + audioPolicyManager_.SendLoudVolumeModeToDsp(funcHoldType, state); +} + int32_t AudioVolumeManager::SetAppVolumeLevel(int32_t appUid, int32_t volumeLevel) { AUDIO_INFO_LOG("enter AudioVolumeManager::SetAppVolumeLevel"); diff --git a/services/audio_policy/server/domain/volume/test/BUILD.gn b/services/audio_policy/server/domain/volume/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..7c743cb6b8dd3f744d064f0e0a2409b4d0619640 --- /dev/null +++ b/services/audio_policy/server/domain/volume/test/BUILD.gn @@ -0,0 +1,100 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") + +group("audio_volume_unittest_packages") { + testonly = true + deps = [ + ":audio_volume_unit_test", + ] +} + +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +ohos_unittest("audio_volume_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./audio_safe_volume_notification_impl_unit_test/include", + "../include", + "../../../../../../interfaces/inner_api/native/audiocommon/include", + "../../../../../../interfaces/inner_api/native/audiomanager/include", + "../../../../../../services/audio_service/client/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "distributed_notification_service:ans_innerkits", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ + "./audio_safe_volume_notification_impl_unit_test/src/audio_safe_volume_notification_impl_unit_test.cpp", + ] + + deps = [ + "../../../../../audio_policy:audio_policy_common", + "../../../../../../services/audio_policy/server/domain/volume:audio_safe_volume_notification_impl", + ] +} \ No newline at end of file diff --git a/services/audio_policy/server/domain/volume/test/audio_safe_volume_notification_impl_unit_test/include/audio_safe_volume_notification_impl_unit_test.h b/services/audio_policy/server/domain/volume/test/audio_safe_volume_notification_impl_unit_test/include/audio_safe_volume_notification_impl_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..827c2ddda10dced8f82604b43d5e01ac0dac7b86 --- /dev/null +++ b/services/audio_policy/server/domain/volume/test/audio_safe_volume_notification_impl_unit_test/include/audio_safe_volume_notification_impl_unit_test.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_SAFE_VOLUME_NOTIFICATION_IMPL_UNIT_TEST_H +#define AUDIO_SAFE_VOLUME_NOTIFICATION_IMPL_UNIT_TEST_H + +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "audio_safe_volume_notification_impl.h" +#include "notification_request.h" +#include "resource_manager_adapter.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioSafeVolumeNotificationImplUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_SAFE_VOLUME_NOTIFICATION_IMPL_UNIT_TEST_H diff --git a/services/audio_policy/server/domain/volume/test/audio_safe_volume_notification_impl_unit_test/src/audio_safe_volume_notification_impl_unit_test.cpp b/services/audio_policy/server/domain/volume/test/audio_safe_volume_notification_impl_unit_test/src/audio_safe_volume_notification_impl_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..57fdbe8669b3b64f794c39553405f74e1f37668d --- /dev/null +++ b/services/audio_policy/server/domain/volume/test/audio_safe_volume_notification_impl_unit_test/src/audio_safe_volume_notification_impl_unit_test.cpp @@ -0,0 +1,183 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_safe_volume_notification_impl_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" +#include +#include +#include +using namespace std; +using namespace std::chrono; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void AudioSafeVolumeNotificationImplUnitTest::SetUpTestCase(void) {} +void AudioSafeVolumeNotificationImplUnitTest::TearDownTestCase(void) {} +void AudioSafeVolumeNotificationImplUnitTest::SetUp(void) {} +void AudioSafeVolumeNotificationImplUnitTest::TearDown(void) {} + +#define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__) + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_001 + * @tc.desc : Test AudioHapticManagerImpl SetTitleAndText interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_001, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + bool ret = impl.SetTitleAndText(RESTORE_VOLUME_NOTIFICATION_ID, nullptr); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_002 + * @tc.desc : Test AudioHapticManagerImpl SetTitleAndText interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_002, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + auto normal = std::make_shared(); + bool ret = impl.SetTitleAndText(RESTORE_VOLUME_NOTIFICATION_ID, normal); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_003 + * @tc.desc : Test AudioHapticManagerImpl SetTitleAndText interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_003, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + auto normal = std::make_shared(); + bool ret = impl.SetTitleAndText(INCREASE_VOLUME_NOTIFICATION_ID, normal); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_004 + * @tc.desc : Test AudioHapticManagerImpl SetTitleAndText interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_004, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + auto normal = std::make_shared(); + + constexpr int32_t INVALID_ID = -1; + bool ret = impl.SetTitleAndText(INVALID_ID, normal); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_005 + * @tc.desc : Test AudioHapticManagerImpl GetButtonName interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_005, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + std::string result = impl.GetButtonName(RESTORE_VOLUME_NOTIFICATION_ID); + EXPECT_FALSE(result.empty()); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_006 + * @tc.desc : Test AudioHapticManagerImpl GetButtonName interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_006, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + std::string result = impl.GetButtonName(INCREASE_VOLUME_NOTIFICATION_ID); + EXPECT_FALSE(result.empty()); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_007 + * @tc.desc : Test AudioHapticManagerImpl GetButtonName interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_007, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + constexpr uint32_t INVALID_ID = -1; + std::string result = impl.GetButtonName(INVALID_ID); + EXPECT_TRUE(result.empty()); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_008 + * @tc.desc : Test AudioHapticManagerImpl GetPixelMap interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_008, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + impl.iconPixelMap_ = std::shared_ptr(reinterpret_cast(0x1), [](auto) {}); + bool ret = impl.GetPixelMap(); + EXPECT_FALSE(ret); + EXPECT_NE(impl.iconPixelMap_, nullptr); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_009 + * @tc.desc : Test AudioHapticManagerImpl GetPixelMap interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_009, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + impl.iconPixelMap_.reset(); + bool ret = impl.GetPixelMap(); + EXPECT_TRUE(ret); + EXPECT_NE(impl.iconPixelMap_, nullptr); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_010 + * @tc.desc : Test AudioHapticManagerImpl PublishSafeVolumeNotification interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_010, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + auto pixelMap = std::make_shared(); + impl.iconPixelMap_ = pixelMap; + constexpr int32_t INVALID_ID = -1; + impl.PublishSafeVolumeNotification(INVALID_ID); + EXPECT_NE(impl.iconPixelMap_, nullptr); +} + +/** + * @tc.name : Test AudioSafeVolumeNotificationImpl. + * @tc.number: AudioSafeVolumeNotificationImpl_011 + * @tc.desc : Test AudioHapticManagerImpl PublishSafeVolumeNotification interface. + */ +HWTEST(AudioSafeVolumeNotificationImplUnitTest, AudioSafeVolumeNotificationImpl_011, TestSize.Level4) +{ + AudioSafeVolumeNotificationImpl impl; + auto pixelMap = std::make_shared(); + impl.iconPixelMap_ = pixelMap; + impl.PublishSafeVolumeNotification(RESTORE_VOLUME_NOTIFICATION_ID); + EXPECT_NE(impl.iconPixelMap_, nullptr); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/infra/appclient/include/audio_background_manager.h b/services/audio_policy/server/infra/appclient/include/audio_background_manager.h index f2da3516e5d5e2027720d259362ddf2dab3e0c9f..09c7475c3174b4fa1e44b758e3150a3cce38cb4e 100644 --- a/services/audio_policy/server/infra/appclient/include/audio_background_manager.h +++ b/services/audio_policy/server/infra/appclient/include/audio_background_manager.h @@ -59,6 +59,8 @@ public: int32_t NotifyFreezeStateChange(const std::set &pidList, const bool isFreeze); int32_t ResetAllProxy(); void HandleFreezeStateChange(const int32_t pid, bool isFreeze); + void WriteAppStateChangeSysEvent(int32_t pid, AppState appState, bool isAdd); + void RecoryAppState(); private: AudioBackgroundManager() : streamCollector_(AudioStreamCollector::GetAudioStreamCollector()) {} diff --git a/services/audio_policy/server/infra/appclient/src/audio_background_manager.cpp b/services/audio_policy/server/infra/appclient/src/audio_background_manager.cpp index 66890864a9fc4d1103c02357ebf000f613624476..833a8eb2086c9ea451fdf0b93b077f23187efc7c 100644 --- a/services/audio_policy/server/infra/appclient/src/audio_background_manager.cpp +++ b/services/audio_policy/server/infra/appclient/src/audio_background_manager.cpp @@ -28,6 +28,7 @@ #include "background_task_listener.h" #include "background_task_subscriber.h" #include "background_task_mgr_helper.h" +#include "media_monitor_manager.h" namespace OHOS { namespace AudioStandard { @@ -133,6 +134,7 @@ void AudioBackgroundManager::NotifyAppStateChange(const int32_t uid, const int32 AUDIO_INFO_LOG("OnBackground with uid: %{public}d", uid); backgroundMuteListener_->OnBackgroundMute(uid); } + WriteAppStateChangeSysEvent(pid, appStatesMap_[pid], true); } void AudioBackgroundManager::NotifyBackgroundTaskStateChange(const int32_t uid, const int32_t pid, bool hasBackgroundTask) @@ -154,6 +156,7 @@ void AudioBackgroundManager::NotifyBackgroundTaskStateChange(const int32_t uid, streamCollector_.HandleBackTaskStateChange(uid, appState.hasSession); } } + WriteAppStateChangeSysEvent(pid, appStatesMap_[pid], true); } int32_t AudioBackgroundManager::NotifySessionStateChange(const int32_t uid, const int32_t pid, const bool hasSession) @@ -173,6 +176,7 @@ int32_t AudioBackgroundManager::NotifySessionStateChange(const int32_t uid, cons appState.hasBackTask, appState.isFreeze); HandleSessionStateChange(uid, pid); } + WriteAppStateChangeSysEvent(pid, appStatesMap_[pid], true); return SUCCESS; } @@ -212,6 +216,7 @@ int32_t AudioBackgroundManager::NotifyFreezeStateChange(const std::set appState.hasBackTask, appState.isFreeze); HandleFreezeStateChange(pid, isFreeze); } + WriteAppStateChangeSysEvent(pid, appStatesMap_[pid], true); } return SUCCESS; } @@ -241,6 +246,24 @@ void AudioBackgroundManager::HandleFreezeStateChange(const int32_t pid, bool isF } } +void AudioBackgroundManager::WriteAppStateChangeSysEvent(int32_t pid, AppState appState, bool isAdd) +{ + AUDIO_INFO_LOG("pid %{public}d is add %{public}d, isFreeze %{public}d, isBack %{public}d, hasSession %{public}d," + "hasBackTask %{public}d, isBinder %{public}d", pid, isAdd, appState.isFreeze, appState.isBack, + appState.hasSession, appState.hasBackTask, appState.isBinder); + std::shared_ptr bean = std::make_shared( + Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::APP_BACKGROUND_STATE, + Media::MediaMonitor::BEHAVIOR_EVENT); + bean->Add("PID", static_cast(pid)); + bean->Add("IS_FREEZE", static_cast(appState.isFreeze)); + bean->Add("IS_BACK", static_cast(appState.isBack)); + bean->Add("HAS_SESSION", static_cast(appState.hasSession)); + bean->Add("HAS_BACK_TASK", static_cast(appState.hasBackTask)); + bean->Add("IS_BINDER", static_cast(appState.isBinder)); + bean->Add("IS_ADD", isAdd); + Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean); +} + void AudioBackgroundManager::InsertIntoAppStatesMap(int32_t pid, AppState appState) { appStatesMap_.insert(std::make_pair(pid, appState)); @@ -249,10 +272,38 @@ void AudioBackgroundManager::InsertIntoAppStatesMap(int32_t pid, AppState appSta appState.hasBackTask, appState.isFreeze); } +void AudioBackgroundManager::RecoryAppState() +{ + std::lock_guard lock(appStatesMapMutex_); + AUDIO_INFO_LOG("Start recovery app state."); + std::map> appStateMap; + Media::MediaMonitor::MediaMonitorManager::GetInstance().GetAudioAppStateMsg(appStateMap); + if (appStateMap.size() == 0) { + AUDIO_INFO_LOG("the length of appStateMap is 0 and does not need to recory"); + } else { + for (auto &appStateInfo : appStateMap) { + std::shared_ptr info = appStateInfo.second; + AppState appState; + appState.isFreeze = info->isFreeze_; + appState.isBack = info->isBack_; + appState.hasSession = info->hasSession_; + appState.hasBackTask = info->hasBackTask_; + appState.isBinder = info->isBinder_; + appStatesMap_.emplace(appStateInfo.first, appState); + AUDIO_INFO_LOG("pid %{public}d, isFreeze %{public}d, isBack %{public}d," + "hasSession %{public}d, hasBackTask %{public}d, isBinder %{public}d", appStateInfo.first, + appState.isFreeze, appState.isBack, appState.hasSession, appState.hasBackTask, appState.isBinder); + } + } +} + void AudioBackgroundManager::DeleteFromMap(int32_t pid) { if (FindKeyInMap(pid)) { + std::lock_guard lock(appStatesMapMutex_); + AppState appState = appStatesMap_[pid]; appStatesMap_.erase(pid); + WriteAppStateChangeSysEvent(pid, appState, false); AUDIO_INFO_LOG("Delete pid: %{public}d success.", pid); } else { AUDIO_DEBUG_LOG("Delete pid: %{public}d failed. It does nt exist", pid); diff --git a/services/audio_policy/server/infra/async_action_handler/include/audio_policy_server_handler.h b/services/audio_policy/server/infra/async_action_handler/include/audio_policy_server_handler.h index 810bba8633fca14bd0e1d76573f34fcff8a9c3f8..1a94a5eb4039d55acde2f40e7f100f673cf033cb 100644 --- a/services/audio_policy/server/infra/async_action_handler/include/audio_policy_server_handler.h +++ b/services/audio_policy/server/infra/async_action_handler/include/audio_policy_server_handler.h @@ -72,7 +72,6 @@ public: SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE, HEAD_TRACKING_ENABLED_CHANGE, HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE, - PIPE_STREAM_CLEAN_EVENT, AUDIO_SESSION_DEACTIVE_EVENT, MICROPHONE_BLOCKED, NN_STATE_CHANGE, @@ -199,7 +198,6 @@ public: bool SendHeadTrackingEnabledChangeEvent(const bool &enabled); bool SendHeadTrackingEnabledChangeForAnyDeviceEvent( const std::shared_ptr &selectedAudioDevice, const bool &enabled); - bool SendPipeStreamCleanEvent(AudioPipeType pipeType); int32_t SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable); int32_t SetCallbackRendererInfo(const AudioRendererInfo &rendererInfo); int32_t SetCallbackCapturerInfo(const AudioCapturerInfo &capturerInfo); @@ -248,7 +246,6 @@ private: void HandleSpatializatonEnabledChangeForCurrentDeviceEvent(const AppExecFwk::InnerEvent::Pointer &event); void HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event); void HandleHeadTrackingEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer &event); - void HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer &event); void HandleAudioSessionDeactiveCallback(const AppExecFwk::InnerEvent::Pointer &event); void HandleNnStateChangeEvent(const AppExecFwk::InnerEvent::Pointer &event); void HandleAudioSceneChange(const AppExecFwk::InnerEvent::Pointer &event); diff --git a/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp b/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp index e97e313474a859821e8a6fe398cd1d1fbfff030a..a188951ab3398e5d47791c8cffee26ffd0073c92 100644 --- a/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp +++ b/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp @@ -637,16 +637,6 @@ bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeForAnyDeviceEvent( return ret; } -bool AudioPolicyServerHandler::SendPipeStreamCleanEvent(AudioPipeType pipeType) -{ - auto eventContextObj = std::make_shared(pipeType); - lock_guard runnerlock(runnerMutex_); - bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT, - eventContextObj)); - CHECK_AND_RETURN_RET_LOG(ret, ret, "Send PIPE_STREAM_CLEAN_EVENT event failed"); - return ret; -} - bool AudioPolicyServerHandler::SendFormatUnsupportedErrorEvent(const AudioErrors &errorCode) { std::shared_ptr eventContextObj = std::make_shared(); @@ -1478,14 +1468,6 @@ void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeForAnyDeviceEvent( } } -void AudioPolicyServerHandler::HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer &event) -{ - std::shared_ptr eventContextObj = event->GetSharedObject(); - CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr"); - AudioPipeType pipeType = static_cast(*eventContextObj); - AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType); -} - void AudioPolicyServerHandler::HandleFormatUnsupportedErrorEvent(const AppExecFwk::InnerEvent::Pointer &event) { std::shared_ptr eventContextObj = event->GetSharedObject(); @@ -1547,9 +1529,6 @@ void AudioPolicyServerHandler::HandleServiceEvent(const uint32_t &eventId, case EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT: HandleSendRecreateCapturerStreamEvent(event); break; - case EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT: - HandlePipeStreamCleanEvent(event); - break; default: break; } diff --git a/services/audio_policy/server/infra/config/file/audio_interrupt_policy_config.xml b/services/audio_policy/server/infra/config/file/audio_interrupt_policy_config.xml index 9ef260c471ba67afdd6d56a17e08b4ef16c0dffd..5e4d5020caaffb9879f6178d845fd3a999a6b439 100644 --- a/services/audio_policy/server/infra/config/file/audio_interrupt_policy_config.xml +++ b/services/audio_policy/server/infra/config/file/audio_interrupt_policy_config.xml @@ -30,6 +30,7 @@ + @@ -49,7 +50,6 @@ - @@ -1018,7 +1018,6 @@ - @@ -1314,7 +1313,6 @@ - @@ -1326,6 +1324,7 @@ + diff --git a/services/audio_policy/server/infra/config/parser/include/audio_source_strategy_parser.h b/services/audio_policy/server/infra/config/parser/include/audio_source_strategy_parser.h new file mode 100644 index 0000000000000000000000000000000000000000..6d0449bb180ceace99b3a06a60f08b25b896ec25 --- /dev/null +++ b/services/audio_policy/server/infra/config/parser/include/audio_source_strategy_parser.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2025-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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef AUDIO_SOURCE_STRATEGY_PARSER_H +#define AUDIO_SOURCE_STRATEGY_PARSER_H + +#include +#include +#include "audio_errors.h" +#include "audio_info.h" +#include "audio_policy_log.h" +#include "audio_xml_parser.h" +#include "audio_definition_adapter_info.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioSourceStrategyParser { +public: + AudioSourceStrategyParser(); + virtual ~AudioSourceStrategyParser(); + bool LoadConfig(); + +private: +#ifdef USE_CONFIG_POLICY + static constexpr char AUDIO_SOURCE_STRATEGY_CONFIG_FILE[] = "etc/audio/audio_source_strategy.xml"; +#else + static constexpr char AUDIO_SOURCE_STRATEGY_CONFIG_FILE[] = "/system/etc/audio/audio_source_strategy.xml"; +#endif + std::shared_ptr curNode_ = nullptr; + void ParseSourceStrategyMap(std::shared_ptr curNode, const std::string &source, + const std::string &hdiSource, std::shared_ptr> + &sourceStrategyMap); + void ParseConfig(std::shared_ptr curNode, + std::shared_ptr> &sourceStrategyMap); + void AddSourceStrategyMap(std::shared_ptr curNode, const std::string &source, + const std::string &hdiSource, std::shared_ptr> + &sourceStrategyMap); + static const std::unordered_map sourceTypeMap; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_SOURCE_STRATEGY_PARSER_H + diff --git a/services/audio_policy/server/infra/config/parser/src/audio_policy_config_parser.cpp b/services/audio_policy/server/infra/config/parser/src/audio_policy_config_parser.cpp index 8e9289d252a60709d73aaa20a645501cde5b6228..364bbde2ceaa33e332a746241f6294c37c5c925e 100644 --- a/services/audio_policy/server/infra/config/parser/src/audio_policy_config_parser.cpp +++ b/services/audio_policy/server/infra/config/parser/src/audio_policy_config_parser.cpp @@ -294,6 +294,15 @@ void AudioPolicyConfigParser::ParseAttributeByName(AttributeInfo &attributeInfo, } } else if (attributeInfo.name_ == "preload") { pipeInfo->preloadAttr_ = AudioDefinitionPolicyUtils::preloadStrToEnum[attributeInfo.value_]; + } else if (attributeInfo.name_ == "suspend_idle_timeout") { + std::string value = attributeInfo.value_; + int timeout = 0; + auto [ptr, ec] = std::from_chars(value.data(), value.data() + value.size(), timeout); + if (ec == std::errc{} && ptr == value.data() + value.size()) { + pipeInfo->suspendIdleTimeout_ = static_cast(timeout); + } else { + pipeInfo->suspendIdleTimeout_ = DEFAULT_SUSPEND_TIME_IN_MS; + } } } @@ -701,6 +710,7 @@ void AudioPolicyConfigParser::GetCommontAudioModuleInfo(std::shared_ptrpaProp_.fixedLatency_; audioModuleInfo.renderInIdleState = pipeInfo->paProp_.renderInIdleState_; + audioModuleInfo.suspendIdleTimeout = pipeInfo->suspendIdleTimeout_; } std::string AudioPolicyConfigParser::GetAudioModuleInfoName(std::string &pipeInfoName, diff --git a/services/audio_policy/server/infra/config/parser/src/audio_source_strategy_parser.cpp b/services/audio_policy/server/infra/config/parser/src/audio_source_strategy_parser.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a51cd0b9ebcf583c9deb4ae0bd74d03047c9a962 --- /dev/null +++ b/services/audio_policy/server/infra/config/parser/src/audio_source_strategy_parser.cpp @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2025-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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef LOG_TAG +#define LOG_TAG "AudioSourceStrategyParser" +#endif + +#include "audio_source_strategy_parser.h" +#include "audio_utils.h" +#include "audio_definition_adapter_info.h" +#ifdef USE_CONFIG_POLICY +#include "config_policy_utils.h" +#endif + +#include "media_monitor_manager.h" + +namespace OHOS { +namespace AudioStandard { + +const std::unordered_map AudioSourceStrategyParser::sourceTypeMap = { + {"SOURCE_TYPE_MIC", SOURCE_TYPE_MIC}, + {"SOURCE_TYPE_CAMCORDER", SOURCE_TYPE_CAMCORDER}, + {"SOURCE_TYPE_VOICE_RECOGNITION", SOURCE_TYPE_VOICE_RECOGNITION}, + {"SOURCE_TYPE_PLAYBACK_CAPTURE", SOURCE_TYPE_PLAYBACK_CAPTURE}, + {"SOURCE_TYPE_WAKEUP", SOURCE_TYPE_WAKEUP}, + {"SOURCE_TYPE_VOICE_COMMUNICATION", SOURCE_TYPE_VOICE_COMMUNICATION}, + {"SOURCE_TYPE_VOICE_CALL", SOURCE_TYPE_VOICE_CALL}, + {"SOURCE_TYPE_ULTRASONIC", SOURCE_TYPE_ULTRASONIC}, + {"SOURCE_TYPE_VIRTUAL_CAPTURE", SOURCE_TYPE_VIRTUAL_CAPTURE}, + {"SOURCE_TYPE_VOICE_MESSAGE", SOURCE_TYPE_VOICE_MESSAGE}, + {"SOURCE_TYPE_VOICE_TRANSCRIPTION", SOURCE_TYPE_VOICE_TRANSCRIPTION}, + {"SOURCE_TYPE_UNPROCESSED", SOURCE_TYPE_UNPROCESSED}, + {"SOURCE_TYPE_LIVE", SOURCE_TYPE_LIVE}, + {"SOURCE_TYPE_EC", SOURCE_TYPE_EC}, + {"SOURCE_TYPE_MIC_REF", SOURCE_TYPE_MIC_REF} +}; + +AudioSourceStrategyParser::AudioSourceStrategyParser() +{ + curNode_ = AudioXmlNode::Create(); + AUDIO_DEBUG_LOG("AudioSourceStrategyParser ctor"); +} + +AudioSourceStrategyParser::~AudioSourceStrategyParser() +{ + if (curNode_ != nullptr) { + curNode_->FreeDoc(); + curNode_ = nullptr; + } + AUDIO_DEBUG_LOG("AudioSourceStrategyParser dtor"); +} + +bool AudioSourceStrategyParser::LoadConfig() +{ +#ifdef USE_CONFIG_POLICY + char buf[MAX_PATH_LEN]; + char *path = GetOneCfgFile(AUDIO_SOURCE_STRATEGY_CONFIG_FILE, buf, MAX_PATH_LEN); +#else + const char *path = AUDIO_SOURCE_STRATEGY_CONFIG_FILE; +#endif + CHECK_AND_RETURN_RET_LOG(path != nullptr && *path != '\0', ERROR, "invalid path!"); + if (curNode_->Config(path, nullptr, 0) != SUCCESS) { + AUDIO_ERR_LOG("load path: %{public}s fail!", path); + curNode_->FreeDoc(); + curNode_ = nullptr; + return false; + } + + AUDIO_INFO_LOG("LoadConfig enter success"); + CHECK_AND_RETURN_RET_LOG(curNode_->IsNodeValid(), ERROR, "root element is null"); + if (!curNode_->CompareName("audio_source_strategy")) { + AUDIO_ERR_LOG("Missing tag - audio_source_strategy in : %s", AUDIO_SOURCE_STRATEGY_CONFIG_FILE); + curNode_->FreeDoc(); + curNode_ = nullptr; + return false; + } + + AUDIO_INFO_LOG("LoadConfig audio_source_strategy success"); + curNode_->MoveToChildren(); + CHECK_AND_RETURN_RET_LOG(curNode_->IsNodeValid(), ERROR, "Missing child: %s", AUDIO_SOURCE_STRATEGY_CONFIG_FILE); + + std::shared_ptr> sourceStrategyMap = + std::make_shared>(); + while (curNode_->IsNodeValid()) { + if (curNode_->CompareName("audio_source_config")) { + ParseConfig(curNode_->GetChildrenNode(), sourceStrategyMap); + break; + } else { + curNode_->MoveToNext(); + } + } + curNode_->FreeDoc(); + curNode_ = nullptr; + + AudioSourceStrategyData &config = AudioSourceStrategyData::GetInstance(); + config.SetSourceStrategyMap(sourceStrategyMap); + return true; +} + +void AudioSourceStrategyParser::ParseSourceStrategyMap(std::shared_ptr curNode, const std::string &source, + const std::string &hdiSource, std::shared_ptr> &sourceStrategyMap) +{ + while (curNode->IsNodeValid()) { + if (curNode->CompareName("item")) { + AUDIO_DEBUG_LOG("node type: Element, name: %s", curNode->GetName().c_str()); + AddSourceStrategyMap(curNode, source, hdiSource, sourceStrategyMap); + } + curNode->MoveToNext(); + } +} + +void AudioSourceStrategyParser::ParseConfig(std::shared_ptr curNode, + std::shared_ptr> &sourceStrategyMap) +{ + if (sourceStrategyMap == nullptr) { + AUDIO_ERR_LOG("sourceStrategyMap is null"); + return; + } + while (curNode->IsNodeValid()) { + if (curNode->IsElementNode()) { + std::string typeStr_source; + std::string typeStr_hdiSource; + curNode->GetProp("source", typeStr_source); + curNode->GetProp("hdiSource", typeStr_hdiSource); + AUDIO_INFO_LOG("source type: %{public}s, hdiSource type: %{public}s", + typeStr_source.c_str(), typeStr_hdiSource.c_str()); + ParseSourceStrategyMap(curNode->GetChildrenNode(), typeStr_source, typeStr_hdiSource, sourceStrategyMap); + } + curNode->MoveToNext(); + } +} + +void AudioSourceStrategyParser::AddSourceStrategyMap(std::shared_ptr curNode, const std::string &source, + const std::string &hdiSource, std::shared_ptr> &sourceStrategyMap) +{ + AUDIO_INFO_LOG("enter"); + if (source.empty() || hdiSource.empty()) { + AUDIO_ERR_LOG("param null"); + return; + } + + std::string adapterStr; + std::string pipeStr; + std::string priorityStr; + std::string audioFlagStr; + + curNode->GetProp("adapter", adapterStr); + curNode->GetProp("pipe", pipeStr); + curNode->GetProp("audioFlag", audioFlagStr); + curNode->GetProp("priority", priorityStr); + + int priority = 0; + if (!priorityStr.empty()) { + priority = std::stoi(priorityStr); + } + + auto sourceTypeIt = sourceTypeMap.find(source); + if (sourceTypeIt == sourceTypeMap.end()) { + AUDIO_ERR_LOG("sourceType: %{public}s is not in sourceTypeMap", source.c_str()); + return; + } + + AudioFlag audioFlag; + auto it = AudioDefinitionPolicyUtils::flagStrToEnum.find(audioFlagStr); + if (it != AudioDefinitionPolicyUtils::flagStrToEnum.end()) { + audioFlag = it->second; + } else { + AUDIO_ERR_LOG("flagStrToEnum is null"); + return; + } + + SourceType sourceType = sourceTypeIt->second; + sourceStrategyMap->emplace(sourceType, + AudioSourceStrategyType(hdiSource, adapterStr, pipeStr, audioFlag, priority)); + AUDIO_INFO_LOG("sourceType: %{public}d, source: %{public}s, hdiSource: %{public}s, adapterStr: %{public}s, " + "pipeStr: %{public}s, audioFlag: %{public}u, priority: %{public}d", + sourceType, source.c_str(), hdiSource.c_str(), adapterStr.c_str(), pipeStr.c_str(), audioFlag, + priority); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/infra/config/parser/test/BUILD.gn b/services/audio_policy/server/infra/config/parser/test/BUILD.gn index 0cbc3ee0b780da87c71d48e4d8138877e47c41ca..2bdebd70c8f93d1dc8d0f9ee4428e7bf80330bc6 100644 --- a/services/audio_policy/server/infra/config/parser/test/BUILD.gn +++ b/services/audio_policy/server/infra/config/parser/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../../../accessibility.gni") import("../../../../../../../appgallery.gni") -import("../../../../../../../av_session.gni") import("../../../../../../../bluetooth_part.gni") import("../../../../../../../config.gni") @@ -25,10 +24,12 @@ group("audio_policy_config_parser_unittest_packages") { ":audio_concurrency_parser_unit_test", ":audio_focus_parser_unit_test", ":audio_tone_parser_test", + ":audio_volume_parser_unit_test", ] } module_output_path = "audio_framework/audio_framework_policy/audio_policy_config_parser" +audio_framework_root = "../../../../../../.." ohos_unittest("audio_focus_parser_unit_test") { module_out_path = module_output_path @@ -50,6 +51,16 @@ ohos_unittest("audio_focus_parser_unit_test") { cflags_cc = cflags cflags_cc += [ "-fno-access-control" ] + sanitize = { + cfi = true + cfi_cross_dso = false + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = false + blocklist = "${audio_framework_root}/cfi_blocklist.txt" + } + external_deps = [ "bluetooth:btframework", "c_utils:utils", @@ -95,11 +106,12 @@ ohos_unittest("audio_concurrency_parser_unit_test") { sanitize = { cfi = true - cfi_cross_dso = true + cfi_cross_dso = false boundary_sanitize = true debug = false integer_overflow = true - ubsan = true + ubsan = false + blocklist = "${audio_framework_root}/cfi_blocklist.txt" } external_deps = [ @@ -147,6 +159,59 @@ ohos_unittest("audio_tone_parser_test") { cflags_cc = cflags cflags_cc += [ "-fno-access-control" ] + sanitize = { + cfi = true + cfi_cross_dso = false + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = false + blocklist = "${audio_framework_root}/cfi_blocklist.txt" + } + + external_deps = [ + "bluetooth:btframework", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "googletest:gmock", + "hilog:libhilog", + "init:libbegetutil", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + ] + + deps = [ "../../../../../../audio_policy:audio_policy_service_static" ] + + defines = [ "FEATURE_DTMF_TONE" ] +} + +ohos_unittest("audio_volume_parser_unit_test") { + module_out_path = module_output_path + + sources = [ "./unittest/audio_volume_parser_unit_test/src/audio_volume_parser_unit_test.cpp" ] + + include_dirs = [ + "./unittest/audio_volume_parser_unit_test/include", + "../../../../../../../interfaces/inner_api/native/audiomanager/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + sanitize = { cfi = true cfi_cross_dso = true diff --git a/services/audio_policy/server/infra/config/parser/test/unittest/audio_volume_parser_unit_test/include/audio_volume_parser_unit_test.h b/services/audio_policy/server/infra/config/parser/test/unittest/audio_volume_parser_unit_test/include/audio_volume_parser_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..f0dfb1a3a176f58c70da8ad2a4d28e209dde9e77 --- /dev/null +++ b/services/audio_policy/server/infra/config/parser/test/unittest/audio_volume_parser_unit_test/include/audio_volume_parser_unit_test.h @@ -0,0 +1,42 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AUDIO_VOLUME_PARSER_UNIT_TEST_H +#define AUDIO_VOLUME_PARSER_UNIT_TEST_H + +#include "gtest/gtest.h" + +#include "audio_volume_parser.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioVolumeParserUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); + +public: + std::shared_ptr audioVolumeParser_ = nullptr; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_VOLUME_PARSER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/infra/config/parser/test/unittest/audio_volume_parser_unit_test/src/audio_volume_parser_unit_test.cpp b/services/audio_policy/server/infra/config/parser/test/unittest/audio_volume_parser_unit_test/src/audio_volume_parser_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b4f96662fef46d6ce31680251540919fc654eac8 --- /dev/null +++ b/services/audio_policy/server/infra/config/parser/test/unittest/audio_volume_parser_unit_test/src/audio_volume_parser_unit_test.cpp @@ -0,0 +1,134 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "audio_volume_parser_unit_test.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { +const std::vector VOLUME_POINTS = { + {0, -2700}, + {33, -1800}, + {66, -900}, + {100, 0} +}; + +void AudioVolumeParserUnitTest::SetUpTestCase(void) {} +void AudioVolumeParserUnitTest::TearDownTestCase(void) {} +void AudioVolumeParserUnitTest::SetUp(void) +{ + audioVolumeParser_ = std::make_shared(); + ASSERT_TRUE(audioVolumeParser_ != nullptr); +} +void AudioVolumeParserUnitTest::TearDown(void) +{ + audioVolumeParser_ = nullptr; +} + +/** + * @tc.name : Test UseVoiceAssistantFixedVolumeConfig. + * @tc.number: AudioVolumeParserUnitTest_001 + * @tc.desc : Test UseVoiceAssistantFixedVolumeConfig. No STREAM_VOICE_ASSISTANT info. + */ +HWTEST_F(AudioVolumeParserUnitTest, AudioVolumeParserUnitTest_001, TestSize.Level2) +{ + StreamVolumeInfoMap streamVolumeInfoMap; + int32_t result = SUCCESS; + + result = audioVolumeParser_->UseVoiceAssistantFixedVolumeConfig(streamVolumeInfoMap); + EXPECT_EQ(result, ERROR); + + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT] = nullptr; + result = audioVolumeParser_->UseVoiceAssistantFixedVolumeConfig(streamVolumeInfoMap); + EXPECT_EQ(result, ERROR); +} + +/** + * @tc.name : Test UseVoiceAssistantFixedVolumeConfig. + * @tc.number: AudioVolumeParserUnitTest_002 + * @tc.desc : Test UseVoiceAssistantFixedVolumeConfig. Incorrect STREAM_VOICE_ASSISTANT info. + */ +HWTEST_F(AudioVolumeParserUnitTest, AudioVolumeParserUnitTest_002, TestSize.Level2) +{ + StreamVolumeInfoMap streamVolumeInfoMap; + + // Init streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]. + std::shared_ptr streamVolumeInfo = std::make_shared(); + streamVolumeInfo->streamType = STREAM_VOICE_ASSISTANT; + streamVolumeInfo->minLevel = 1; + streamVolumeInfo->maxLevel = 15; + streamVolumeInfo->defaultLevel = 7; + std::shared_ptr earpieceDeviceVolumeInfo = std::make_shared(); + earpieceDeviceVolumeInfo->deviceType = EARPIECE_VOLUME_TYPE; + earpieceDeviceVolumeInfo->volumePoints = VOLUME_POINTS; + streamVolumeInfo->deviceVolumeInfos[EARPIECE_VOLUME_TYPE] = earpieceDeviceVolumeInfo; + std::shared_ptr speakerDeviceVolumeInfo = std::make_shared(); + speakerDeviceVolumeInfo->deviceType = SPEAKER_VOLUME_TYPE; + speakerDeviceVolumeInfo->volumePoints = VOLUME_POINTS; + streamVolumeInfo->deviceVolumeInfos[SPEAKER_VOLUME_TYPE] =speakerDeviceVolumeInfo; + std::shared_ptr headsetDeviceVolumeInfo = std::make_shared(); + headsetDeviceVolumeInfo->deviceType = HEADSET_VOLUME_TYPE; + headsetDeviceVolumeInfo->volumePoints = VOLUME_POINTS; + streamVolumeInfo->deviceVolumeInfos[HEADSET_VOLUME_TYPE] = headsetDeviceVolumeInfo; + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT] = streamVolumeInfo; + + // Test UseVoiceAssistantFixedVolumeConfig function. + int32_t result = audioVolumeParser_->UseVoiceAssistantFixedVolumeConfig(streamVolumeInfoMap); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]->minLevel, 0); + EXPECT_EQ( + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]->deviceVolumeInfos[EARPIECE_VOLUME_TYPE]->volumePoints[0].index, 1); + EXPECT_EQ( + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]->deviceVolumeInfos[SPEAKER_VOLUME_TYPE]->volumePoints[0].index, 1); + EXPECT_EQ( + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]->deviceVolumeInfos[HEADSET_VOLUME_TYPE]->volumePoints[0].index, 1); +} + +/** + * @tc.name : Test UseVoiceAssistantFixedVolumeConfig. + * @tc.number: AudioVolumeParserUnitTest_003 + * @tc.desc : Test UseVoiceAssistantFixedVolumeConfig. Incorrect STREAM_VOICE_ASSISTANT info. + */ +HWTEST_F(AudioVolumeParserUnitTest, AudioVolumeParserUnitTest_003, TestSize.Level2) +{ + StreamVolumeInfoMap streamVolumeInfoMap; + + // Init streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]. + std::shared_ptr streamVolumeInfo = std::make_shared(); + streamVolumeInfo->streamType = STREAM_VOICE_ASSISTANT; + streamVolumeInfo->minLevel = 1; + streamVolumeInfo->maxLevel = 15; + streamVolumeInfo->defaultLevel = 7; + std::shared_ptr earpieceDeviceVolumeInfo = std::make_shared(); + earpieceDeviceVolumeInfo->deviceType = EARPIECE_VOLUME_TYPE; + earpieceDeviceVolumeInfo->volumePoints = VOLUME_POINTS; + streamVolumeInfo->deviceVolumeInfos[EARPIECE_VOLUME_TYPE] = earpieceDeviceVolumeInfo; + std::shared_ptr speakerDeviceVolumeInfo = std::make_shared(); + speakerDeviceVolumeInfo->deviceType = SPEAKER_VOLUME_TYPE; + speakerDeviceVolumeInfo->volumePoints = {}; + streamVolumeInfo->deviceVolumeInfos[SPEAKER_VOLUME_TYPE] =speakerDeviceVolumeInfo; + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT] = streamVolumeInfo; + + // Test UseVoiceAssistantFixedVolumeConfig function. + int32_t result = audioVolumeParser_->UseVoiceAssistantFixedVolumeConfig(streamVolumeInfoMap); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]->minLevel, 0); + EXPECT_EQ( + streamVolumeInfoMap[STREAM_VOICE_ASSISTANT]->deviceVolumeInfos[EARPIECE_VOLUME_TYPE]->volumePoints[0].index, 1); +} +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/server/infra/datashare/include/audio_policy_utils.h b/services/audio_policy/server/infra/datashare/include/audio_policy_utils.h index c68e0caa8a20fc96ff2dad11bd48087d2a825e61..3b04ef82300d800c7ae412e64c0a771b643aa3b6 100644 --- a/services/audio_policy/server/infra/datashare/include/audio_policy_utils.h +++ b/services/audio_policy/server/infra/datashare/include/audio_policy_utils.h @@ -64,7 +64,7 @@ public: std::string GetSinkName(const AudioDeviceDescriptor &desc, int32_t sessionId); std::string GetSinkName(std::shared_ptr desc, int32_t sessionId); uint32_t PcmFormatToBytes(AudioSampleFormat format); - std::string GetSourcePortName(DeviceType deviceType); + std::string GetSourcePortName(DeviceType deviceType, uint32_t routeFlag = AUDIO_FLAG_NONE); void UpdateDisplayName(std::shared_ptr deviceDescriptor); void UpdateDisplayNameForRemote(std::shared_ptr &deviceDescriptor); int32_t GetDeviceNameFromDataShareHelper(std::string &deviceName); diff --git a/services/audio_policy/server/infra/datashare/src/audio_policy_utils.cpp b/services/audio_policy/server/infra/datashare/src/audio_policy_utils.cpp index f451e7ae2e389c9a087f73a3cb591b3538f5d875..763d48945c475940c3df380b6dd12f8f99da607d 100644 --- a/services/audio_policy/server/infra/datashare/src/audio_policy_utils.cpp +++ b/services/audio_policy/server/infra/datashare/src/audio_policy_utils.cpp @@ -47,6 +47,7 @@ static const char* AUDIO_SERVICE_PKG = "audio_manager_service"; std::map AudioPolicyUtils::portStrToEnum = { {PRIMARY_SPEAKER, TYPE_PRIMARY}, {PRIMARY_MIC, TYPE_PRIMARY}, + {PRIMARY_AI_MIC, TYPE_PRIMARY}, {PRIMARY_WAKEUP_MIC, TYPE_PRIMARY}, {BLUETOOTH_SPEAKER, TYPE_A2DP}, {BLUETOOTH_MIC, TYPE_A2DP}, @@ -326,13 +327,18 @@ std::string AudioPolicyUtils::GetSinkName(std::shared_ptr } } -std::string AudioPolicyUtils::GetSourcePortName(DeviceType deviceType) +std::string AudioPolicyUtils::GetSourcePortName(DeviceType deviceType, uint32_t routeFlag) { std::string portName = PORT_NONE; switch (deviceType) { case InternalDeviceType::DEVICE_TYPE_MIC: case InternalDeviceType::DEVICE_TYPE_NEARLINK_IN: - portName = PRIMARY_MIC; + if (routeFlag == AUDIO_INPUT_FLAG_AI) { + portName = PRIMARY_AI_MIC; + AUDIO_INFO_LOG("use PRIMARY_AI_IC for devicetype: %{public}d", deviceType); + } else { + portName = PRIMARY_MIC; + } break; case InternalDeviceType::DEVICE_TYPE_USB_ARM_HEADSET: portName = USB_MIC; @@ -386,7 +392,9 @@ std::string AudioPolicyUtils::GetInputDeviceClassBySourcePortName(std::string so {PRIMARY_WAKEUP, PRIMARY_CLASS}, {FILE_SOURCE, FILE_CLASS}, {BLUETOOTH_MIC, A2DP_CLASS}, - {PORT_NONE, INVALID_CLASS} + {PRIMARY_AI_MIC, PRIMARY_CLASS}, + {PORT_NONE, INVALID_CLASS}, + }; std::string deviceClass = INVALID_CLASS; if (sourcePortStrToClassStrMap_.count(sourcePortName) > 0) { @@ -639,7 +647,7 @@ DeviceType AudioPolicyUtils::GetDeviceType(const std::string &deviceName) DeviceType devType = DeviceType::DEVICE_TYPE_NONE; if (deviceName == "Speaker") { devType = DeviceType::DEVICE_TYPE_SPEAKER; - } else if (deviceName == "Built_in_mic") { + } else if (deviceName == "Built_in_mic" || deviceName == PRIMARY_AI_MIC) { devType = DeviceType::DEVICE_TYPE_MIC; } else if (deviceName == "Built_in_wakeup") { devType = DeviceType::DEVICE_TYPE_WAKEUP; diff --git a/services/audio_policy/server/infra/ipc_proxy/include/audio_server_proxy.h b/services/audio_policy/server/infra/ipc_proxy/include/audio_server_proxy.h index b66412a1196352bd75d17d7fb20eb0ad67be8ac8..9e55b517148523051fef77048a4382c322355886 100644 --- a/services/audio_policy/server/infra/ipc_proxy/include/audio_server_proxy.h +++ b/services/audio_policy/server/infra/ipc_proxy/include/audio_server_proxy.h @@ -120,6 +120,7 @@ public: void SetSessionMuteState(const uint32_t sessionId, const bool insert, const bool muteFlag); void SetBtHdiInvalidState(); int32_t ForceStopAudioStreamProxy(StopAudioType audioType); + void SendInterruptEventToAudioServerProxy(InterruptEventInternal interruptEvent, int32_t sessionId); private: AudioServerProxy() {} ~AudioServerProxy() {} diff --git a/services/audio_policy/server/infra/ipc_proxy/src/audio_policy_client_holder.cpp b/services/audio_policy/server/infra/ipc_proxy/src/audio_policy_client_holder.cpp index 5c4a0cd0b339a6ce86a951291b2cb8040c69b1dd..6d45b784b4cce7b856b9f197f427bdcd8ada2623 100644 --- a/services/audio_policy/server/infra/ipc_proxy/src/audio_policy_client_holder.cpp +++ b/services/audio_policy/server/infra/ipc_proxy/src/audio_policy_client_holder.cpp @@ -47,7 +47,7 @@ void AudioPolicyClientHolder::OnAudioFocusAbandoned(const AudioInterrupt &abando void AudioPolicyClientHolder::OnDeviceChange(const DeviceChangeAction &deviceChangeAction) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; deviceChangeAction.SetClientInfo(clientInfo); audioPolicyClient_->OnDeviceChange(deviceChangeAction); } @@ -55,7 +55,7 @@ void AudioPolicyClientHolder::OnDeviceChange(const DeviceChangeAction &deviceCha void AudioPolicyClientHolder::OnMicrophoneBlocked(const MicrophoneBlockedInfo µphoneBlockedInfo) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; microphoneBlockedInfo.SetClientInfo(clientInfo); audioPolicyClient_->OnMicrophoneBlocked(microphoneBlockedInfo); } @@ -88,7 +88,7 @@ void AudioPolicyClientHolder::OnPreferredOutputDeviceUpdated(const AudioRenderer const std::vector> &desc) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; for (auto &deviceDesc : desc) { CHECK_AND_CONTINUE_LOG(deviceDesc != nullptr, "deviceDesc is nullptr."); deviceDesc->SetClientInfo(clientInfo); @@ -100,7 +100,7 @@ void AudioPolicyClientHolder::OnPreferredInputDeviceUpdated(const AudioCapturerI const std::vector> &desc) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; for (auto &deviceDesc : desc) { CHECK_AND_CONTINUE_LOG(deviceDesc != nullptr, "deviceDesc is nullptr."); deviceDesc->SetClientInfo(clientInfo); @@ -112,8 +112,7 @@ void AudioPolicyClientHolder::OnRendererStateChange( std::vector> &audioRendererChangeInfos) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared( - hasBTPermission_, hasSystemPermission_, apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { hasBTPermission_, hasSystemPermission_, apiVersion_ }; for (auto &audioRendererChangeInfo : audioRendererChangeInfos) { CHECK_AND_CONTINUE_LOG(audioRendererChangeInfo != nullptr, "audioRendererChangeInfo is nullptr."); audioRendererChangeInfo->SetClientInfo(clientInfo); @@ -125,8 +124,7 @@ void AudioPolicyClientHolder::OnCapturerStateChange( std::vector> &audioCapturerChangeInfos) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared( - hasBTPermission_, hasSystemPermission_, apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { hasBTPermission_, hasSystemPermission_, apiVersion_ }; for (auto &audioCapturerChangeInfo : audioCapturerChangeInfos) { CHECK_AND_CONTINUE_LOG(audioCapturerChangeInfo != nullptr, "audioCapturerChangeInfo is nullptr."); audioCapturerChangeInfo->SetClientInfo(clientInfo); @@ -138,7 +136,7 @@ void AudioPolicyClientHolder::OnRendererDeviceChange(const uint32_t sessionId, const AudioDeviceDescriptor &deviceInfo, const AudioStreamDeviceChangeReasonExt reason) { CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; deviceInfo.SetClientInfo(clientInfo); audioPolicyClient_->OnRendererDeviceChange(sessionId, deviceInfo, reason); } @@ -179,7 +177,7 @@ void AudioPolicyClientHolder::OnSpatializationEnabledChangeForAnyDevice( CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); CHECK_AND_RETURN_LOG(deviceDescriptor != nullptr, "deviceDescriptor is nullptr."); if (hasSystemPermission_) { - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; deviceDescriptor->SetClientInfo(clientInfo); audioPolicyClient_->OnSpatializationEnabledChangeForAnyDevice(deviceDescriptor, enabled); } else { @@ -209,7 +207,7 @@ void AudioPolicyClientHolder::OnHeadTrackingEnabledChangeForAnyDevice( CHECK_AND_RETURN_LOG(audioPolicyClient_ != nullptr, "audioPolicyClient_ is nullptr."); CHECK_AND_RETURN_LOG(deviceDescriptor != nullptr, "deviceDescriptor is nullptr."); if (hasSystemPermission_) { - auto clientInfo = std::make_shared(apiVersion_); + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion_ }; deviceDescriptor->SetClientInfo(clientInfo); audioPolicyClient_->OnHeadTrackingEnabledChangeForAnyDevice(deviceDescriptor, enabled); } else { diff --git a/services/audio_policy/server/infra/ipc_proxy/src/audio_server_proxy.cpp b/services/audio_policy/server/infra/ipc_proxy/src/audio_server_proxy.cpp index 4e0cb0edff7843441f54db0d81303c66a63ad960..26e34ac9ac97d2699f9bc82fc61f5db4a688c7e7 100644 --- a/services/audio_policy/server/infra/ipc_proxy/src/audio_server_proxy.cpp +++ b/services/audio_policy/server/infra/ipc_proxy/src/audio_server_proxy.cpp @@ -699,5 +699,17 @@ int32_t AudioServerProxy::ForceStopAudioStreamProxy(StopAudioType audioType) IPCSkeleton::SetCallingIdentity(identity); return res; } + +void AudioServerProxy::SendInterruptEventToAudioServerProxy(InterruptEventInternal interruptEvent, + int32_t sessionId) +{ + AUDIO_INFO_LOG("hintType:%{public}d for stream:%{public}u", interruptEvent.hintType, sessionId); + const sptr gsp = GetAudioServerProxy(); + std::string identity = IPCSkeleton::ResetCallingIdentity(); + CHECK_AND_RETURN_LOG(gsp != nullptr, "error for audio server proxy null"); + gsp->SendInterruptEventToAudioServer(sessionId, interruptEvent); + IPCSkeleton::SetCallingIdentity(identity); +} + } } diff --git a/services/audio_policy/server/infra/ipc_proxy/test/BUILD.gn b/services/audio_policy/server/infra/ipc_proxy/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..a9d5318ac5de3f3d104b5012246ea18bd5c805b9 --- /dev/null +++ b/services/audio_policy/server/infra/ipc_proxy/test/BUILD.gn @@ -0,0 +1,83 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../../accessibility.gni") +import("../../../../../../appgallery.gni") +import("../../../../../../bluetooth_part.gni") +import("../../../../../../config.gni") + +group("audio_policy_ipc_proxy_unittest_packages") { + testonly = true + deps = [ + ":audio_policy_client_holder_unit_test", + ] +} + +audio_framework_root = "../../../../../.." +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +ohos_unittest("audio_policy_client_holder_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./unittest/audio_policy_client_holder_unit_test/include", + "../../../include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + sanitize = { + cfi = true + cfi_cross_dso = false + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = false + blocklist = "${audio_framework_root}/cfi_blocklist.txt" + } + + external_deps = [ + "ability_base:want", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "googletest:gmock", + "data_share:datashare_common", + "data_share:datashare_consumer", + "hilog:libhilog", + "ipc:ipc_single", + ] + + sources = [ "./unittest/audio_policy_client_holder_unit_test/src/audio_policy_client_holder_unit_test.cpp" ] + + deps = [ + "../../../../../audio_policy:audio_policy_service_static", + "../../../../../audio_service/idl:audio_framework_interface", + ] +} diff --git a/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/include/audio_policy_client_holder_unit_test.h b/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/include/audio_policy_client_holder_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..552415663e22016d5beca2f2679243932eebc175 --- /dev/null +++ b/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/include/audio_policy_client_holder_unit_test.h @@ -0,0 +1,45 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AUDIO_POLICY_CLIENT_HOLDER_UNIT_TEST_H +#define AUDIO_POLICY_CLIENT_HOLDER_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_policy_client_holder.h" +#include "mock_audio_policy_client.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioPolicyClientHolderUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before the first test case in this test suite + static void SetUpTestCase(void); + // TearDownTestCase: Called after the last test case in this test suite + static void TearDownTestCase(void); + // SetUp: Called before each test case + void SetUp(void); + // TearDown: Called after each test case + void TearDown(void); + +public: + sptr mockClient_ = nullptr; + std::shared_ptr clientHolder_ = nullptr; +}; + +} // namespace AudioStandard +} // namespace OHOS + +#endif // AUDIO_POLICY_CLIENT_HOLDER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/include/mock_audio_policy_client.h b/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/include/mock_audio_policy_client.h new file mode 100644 index 0000000000000000000000000000000000000000..6a9bcd21de4b507aa68082442444be64f807651d --- /dev/null +++ b/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/include/mock_audio_policy_client.h @@ -0,0 +1,108 @@ +/* + * Copyright (C) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MOCK_AUDIO_POLICY_CLIENT_H +#define MOCK_AUDIO_POLICY_CLIENT_H + +#include +#include "iaudio_policy_client.h" + +namespace OHOS { +namespace AudioStandard { + +class MockAudioPolicyClient : public IAudioPolicyClient { +public: + MockAudioPolicyClient() = default; + ~MockAudioPolicyClient() = default; + + MOCK_METHOD(sptr, AsObject, (), (override)); + MOCK_METHOD(ErrCode, OnVolumeKeyEvent, + (const VolumeEvent& volumeEvent), (override)); + MOCK_METHOD(ErrCode, OnAudioFocusInfoChange, + ((const std::vector>& focusInfoList)), (override)); + MOCK_METHOD(ErrCode, OnAudioFocusRequested, + (const AudioInterrupt& requestFocus), (override)); + MOCK_METHOD(ErrCode, OnAudioFocusAbandoned, + (const AudioInterrupt& abandonFocus), (override)); + MOCK_METHOD(ErrCode, OnDeviceChange, + (const DeviceChangeAction& deviceChangeAction), (override)); + MOCK_METHOD(ErrCode, OnAppVolumeChanged, + (int32_t appUid, const VolumeEvent& volumeEvent), (override)); + MOCK_METHOD(ErrCode, OnActiveVolumeTypeChanged, + (int32_t volumeType), (override)); + MOCK_METHOD(ErrCode, OnRingerModeUpdated, + (int32_t ringerMode), (override)); + MOCK_METHOD(ErrCode, OnMicStateUpdated, + (const MicStateChangeEvent& micStateChangeEvent), (override)); + MOCK_METHOD(ErrCode, OnPreferredOutputDeviceUpdated, + (const AudioRendererInfo& rendererInfo, + const std::vector>& desc), (override)); + MOCK_METHOD(ErrCode, OnPreferredInputDeviceUpdated, + (const AudioCapturerInfo& capturerInfo, + const std::vector>& desc), (override)); + MOCK_METHOD(ErrCode, OnRendererStateChange, + (const std::vector>& audioRendererChangeInfos), (override)); + MOCK_METHOD(ErrCode, OnCapturerStateChange, + (const std::vector>& audioCapturerChangeInfos), (override)); + MOCK_METHOD(ErrCode, OnRendererDeviceChange, + (uint32_t sessionId, + const AudioDeviceDescriptor& deviceInfo, + const AudioStreamDeviceChangeReasonExt& reason), (override)); + MOCK_METHOD(ErrCode, OnRecreateRendererStreamEvent, + (uint32_t sessionId, + int32_t streamFlag, + const AudioStreamDeviceChangeReasonExt& reason), (override)); + MOCK_METHOD(ErrCode, OnRecreateCapturerStreamEvent, + (uint32_t sessionId, + int32_t streamFlag, + const AudioStreamDeviceChangeReasonExt& reason), (override)); + MOCK_METHOD(ErrCode, OnHeadTrackingDeviceChange, + ((const std::unordered_map& changeInfo)), (override)); + MOCK_METHOD(ErrCode, OnSpatializationEnabledChange, + (bool enabled), (override)); + MOCK_METHOD(ErrCode, OnSpatializationEnabledChangeForAnyDevice, + (const std::shared_ptr& deviceDescriptor, bool enabled), (override)); + MOCK_METHOD(ErrCode, OnHeadTrackingEnabledChange, + (bool enabled), (override)); + MOCK_METHOD(ErrCode, OnHeadTrackingEnabledChangeForAnyDevice, + (const std::shared_ptr& deviceDescriptor, bool enabled), (override)); + MOCK_METHOD(ErrCode, OnNnStateChange, + (int32_t nnState), (override)); + MOCK_METHOD(ErrCode, OnAudioSessionDeactive, + (int32_t deactiveEvent), (override)); + MOCK_METHOD(ErrCode, OnMicrophoneBlocked, + (const MicrophoneBlockedInfo& microphoneBlockedInfo), (override)); + MOCK_METHOD(ErrCode, OnAudioSceneChange, + (int32_t audioScene), (override)); + MOCK_METHOD(ErrCode, OnSpatializationEnabledChangeForCurrentDevice, + (bool enabled), (override)); + MOCK_METHOD(ErrCode, OnFormatUnsupportedError, + (int32_t errorCode), (override)); + MOCK_METHOD(ErrCode, OnStreamVolumeChange, + (const StreamVolumeEvent& streamVolumeEvent), (override)); + MOCK_METHOD(ErrCode, OnSystemVolumeChange, + (const VolumeEvent& volumeEvent), (override)); + MOCK_METHOD(ErrCode, OnAudioSessionStateChanged, + (int32_t stateChangeHint), (override)); + MOCK_METHOD(ErrCode, OnAudioSessionCurrentDeviceChanged, + (const CurrentOutputDeviceChangedEvent& deviceChangedEvent), (override)); + MOCK_METHOD(ErrCode, OnVolumeDegreeEvent, + (const VolumeEvent& volumeEvent), (override)); +}; + +} // namespace AudioStandard +} // namespace OHOS + +#endif // MOCK_AUDIO_POLICY_CLIENT_H \ No newline at end of file diff --git a/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/src/audio_policy_client_holder_unit_test.cpp b/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/src/audio_policy_client_holder_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a5c7cd11d51f32b7ba9b299e2017be661303786b --- /dev/null +++ b/services/audio_policy/server/infra/ipc_proxy/test/unittest/audio_policy_client_holder_unit_test/src/audio_policy_client_holder_unit_test.cpp @@ -0,0 +1,156 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include "audio_policy_client_holder_unit_test.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +static const int32_t SUCCESS = 0; + +void AudioPolicyClientHolderUnitTest::SetUpTestCase(void) {} +void AudioPolicyClientHolderUnitTest::TearDownTestCase(void) {} +void AudioPolicyClientHolderUnitTest::SetUp(void) +{ + mockClient_ = new MockAudioPolicyClient(); + clientHolder_ = std::make_shared(nullptr); +} + +void AudioPolicyClientHolderUnitTest::TearDown(void) +{ + mockClient_ = nullptr; + clientHolder_ = nullptr; +} + +/** + * @tc.name : Test OnSpatializationEnabledChange. + * @tc.number: AudioPolicyClientHolderTest_OnSpatializationEnabledChange_001 + * @tc.desc : Verify that hasSystemPermission_ == true. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnSpatializationEnabledChange_001, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnSpatializationEnabledChange(_)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = true; + bool enabled = true; + clientHolder_->OnSpatializationEnabledChange(enabled); +} + +/** + * @tc.name : Test OnSpatializationEnabledChange. + * @tc.number: AudioPolicyClientHolderTest_OnSpatializationEnabledChange_002 + * @tc.desc : Verify that hasSystemPermission_ == false. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnSpatializationEnabledChange_002, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnSpatializationEnabledChange(_)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = false; + bool enabled = true; + clientHolder_->OnSpatializationEnabledChange(enabled); +} + +/** + * @tc.name : Test OnSpatializationEnabledChangeForAnyDevice. + * @tc.number: AudioPolicyClientHolderTest_OnSpatializationEnabledChangeForAnyDevice_001 + * @tc.desc : Verify that hasSystemPermission_ == true. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnSpatializationEnabledChangeForAnyDevice_001, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnSpatializationEnabledChangeForAnyDevice(_, _)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = true; + bool enabled = true; + auto deviceDescriptor = std::make_shared(); + clientHolder_->OnSpatializationEnabledChangeForAnyDevice(deviceDescriptor, enabled); +} + +/** + * @tc.name : Test OnSpatializationEnabledChangeForAnyDevice. + * @tc.number: AudioPolicyClientHolderTest_OnSpatializationEnabledChangeForAnyDevice_002 + * @tc.desc : Verify that hasSystemPermission_ == false. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnSpatializationEnabledChangeForAnyDevice_002, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnSpatializationEnabledChangeForAnyDevice(_, _)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = false; + bool enabled = true; + auto deviceDescriptor = std::make_shared(); + clientHolder_->OnSpatializationEnabledChangeForAnyDevice(deviceDescriptor, enabled); +} + +/** + * @tc.name : Test OnHeadTrackingEnabledChang. + * @tc.number: AudioPolicyClientHolderTest_OnHeadTrackingEnabledChange_001 + * @tc.desc : Verify that hasSystemPermission_ == true. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnHeadTrackingEnabledChange_001, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnHeadTrackingEnabledChange(_)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = true; + bool enabled = true; + clientHolder_->OnHeadTrackingEnabledChange(enabled); +} + +/** + * @tc.name : Test OnHeadTrackingEnabledChange. + * @tc.number: AudioPolicyClientHolderTest_OnHeadTrackingEnabledChange_002 + * @tc.desc : Verify that hasSystemPermission_ == false. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnHeadTrackingEnabledChange_002, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnHeadTrackingEnabledChange(_)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = false; + bool enabled = true; + clientHolder_->OnHeadTrackingEnabledChange(enabled); +} + +/** + * @tc.name : Test OnHeadTrackingEnabledChangeForAnyDevice. + * @tc.number: AudioPolicyClientHolderTest_OnHeadTrackingEnabledChangeForAnyDevice_001 + * @tc.desc : Verify that hasSystemPermission_ == true. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnHeadTrackingEnabledChangeForAnyDevice_001, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnHeadTrackingEnabledChangeForAnyDevice(_, _)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = true; + bool enabled = true; + auto deviceDescriptor = std::make_shared(); + clientHolder_->OnHeadTrackingEnabledChangeForAnyDevice(deviceDescriptor, enabled); +} + +/** + * @tc.name : Test OnHeadTrackingEnabledChangeForAnyDevice. + * @tc.number: AudioPolicyClientHolderTest_OnHeadTrackingEnabledChangeForAnyDevice_002 + * @tc.desc : Verify that hasSystemPermission_ == false. + */ +HWTEST_F(AudioPolicyClientHolderUnitTest, OnHeadTrackingEnabledChangeForAnyDevice_002, TestSize.Level4) +{ + EXPECT_CALL(*mockClient_, OnHeadTrackingEnabledChangeForAnyDevice(_, _)).WillOnce(Return(SUCCESS)); + clientHolder_->audioPolicyClient_ = mockClient_; + clientHolder_->hasSystemPermission_ = false; + bool enabled = true; + auto deviceDescriptor = std::make_shared(); + clientHolder_->OnHeadTrackingEnabledChangeForAnyDevice(deviceDescriptor, enabled); +} + +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/server/infra/state_monitor/test/BUILD.gn b/services/audio_policy/server/infra/state_monitor/test/BUILD.gn index 0c7c3fced55e9d1f9e3cadbb978b8786c9ec3e71..1aa43f63901d0cc5cfd8b5cb557e7f327a019f71 100644 --- a/services/audio_policy/server/infra/state_monitor/test/BUILD.gn +++ b/services/audio_policy/server/infra/state_monitor/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../../accessibility.gni") import("../../../../../../appgallery.gni") -import("../../../../../../av_session.gni") import("../../../../../../bluetooth_part.gni") import("../../../../../../config.gni") 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 c624828a0e413d7a1745a897ca55b81d6d4bb7e1..b154ad5b5a248711956360bf03363ec8d28377b1 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 @@ -96,6 +96,8 @@ public: int32_t GetProcessDeviceInfoBySessionId(uint32_t sessionId, AudioDeviceDescriptor &deviceInfo, AudioStreamInfo &streamInfo, bool isReloadProcess = false) override; uint32_t GenerateSessionId() override; + void GetVoiceMuteState(uint32_t sessionId, bool &muteState) override; + void RemoveVoiceMuteState(uint32_t sessionId) override; int32_t LoadSplitModule(const std::string &splitArgs, const std::string &networkId); // IDeviceStatusObserver @@ -126,7 +128,7 @@ public: int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo); void RegisteredTrackerClientDied(pid_t uid, pid_t pid); bool ConnectServiceAdapter(); - void OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName); + void OnReceiveUpdateDeviceNameEvent(const std::string macAddress, const std::string deviceName); int32_t SelectOutputDevice(sptr audioRendererFilter, std::vector> selectedDesc); int32_t SelectInputDevice(sptr audioCapturerFilter, @@ -152,7 +154,6 @@ public: std::vector> GetPreferredInputDeviceDescriptors( AudioCapturerInfo &captureInfo, std::string networkId = LOCAL_NETWORK_ID); std::shared_ptr GetActiveBluetoothDevice(); - std::vector> GetAvailableDevices(AudioDeviceUsage usage); std::vector> GetAvailableMicrophones(); std::vector> GetAudioCapturerMicrophoneDescriptors(int32_t sessionId); int32_t GetCurrentRendererChangeInfos(vector> @@ -162,6 +163,7 @@ public: std::vector> GetExcludedDevices(AudioDeviceUsage audioDevUsage); int32_t FetchOutputDeviceAndRoute(std::string caller, const AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN); + int32_t FetchInputDeviceAndRoute(std::string caller); int32_t GetPreferredOutputStreamType(AudioRendererInfo &rendererInfo, const std::string &bundleName); int32_t GetSessionDefaultOutputDevice(const int32_t callerPid, DeviceType &deviceType); int32_t GetPreferredInputStreamType(AudioCapturerInfo &capturerInfo); @@ -210,6 +212,9 @@ private: AudioStreamInfo &streamInfo); uint32_t GenerateSessionId(); int32_t LoadSplitModule(const std::string &splitArgs, const std::string &networkId); + void SetVoiceMuteState(uint32_t sessionId, bool isMute); + void GetVoiceMuteState(uint32_t sessionId, bool &muteState); + void RemoveVoiceMuteState(uint32_t sessionId); // IDeviceStatusObserver from EventEntry void OnDeviceInfoUpdated(AudioDeviceDescriptor &desc, const DeviceInfoUpdateCommand command); @@ -238,7 +243,7 @@ private: int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo); void RegisteredTrackerClientDied(pid_t uid, pid_t pid); bool ConnectServiceAdapter(); - void OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName); + void OnReceiveUpdateDeviceNameEvent(const std::string macAddress, const std::string deviceName); int32_t SelectOutputDevice(sptr audioRendererFilter, std::vector> selectedDesc); void NotifyDistributedOutputChange(const AudioDeviceDescriptor &deviceDesc); @@ -366,8 +371,8 @@ private: std::shared_ptr remoteDeviceDescriptor); void MoveStreamSource(std::shared_ptr streamDesc); void MoveToNewInputDevice(std::shared_ptr streamDesc); - int32_t MoveToLocalInputDevice( - std::vector sourceOutputs, std::shared_ptr localDeviceDescriptor); + int32_t MoveToLocalInputDevice(std::vector sourceOutputs, + std::shared_ptr localDeviceDescriptor, uint32_t routeFlag = AUDIO_FLAG_NONE); int32_t MoveToRemoteInputDevice( std::vector sourceInputs, std::shared_ptr remoteDeviceDescriptor); int32_t OpenRemoteAudioDevice(std::string networkId, DeviceRole deviceRole, DeviceType deviceType, @@ -393,8 +398,9 @@ private: void UpdateTrackerDeviceChange(const vector> &desc); bool IsForcedNormal(std::shared_ptr &streamDesc); void UpdatePlaybackStreamFlag(std::shared_ptr &streamDesc, bool isCreateProcess); + AudioFlag SetFlagForMmapStream(std::shared_ptr &streamDesc); AudioFlag SetFlagForSpecialStream(std::shared_ptr &streamDesc, bool isCreateProcess); - void UpdateRecordStreamFlag(std::shared_ptr streamDesc); + void UpdateRecordStreamInfo(std::shared_ptr &streamDesc); std::vector FilterSourceOutputs(int32_t sessionId); std::vector GetSourceOutputs(); void UpdateOutputRoute(std::shared_ptr streamDesc); @@ -439,8 +445,6 @@ private: void HandleCommonSourceOpened(std::shared_ptr &pipeInfo); void DelayReleaseOffloadPipe(AudioIOHandle id, uint32_t paIndex, OffloadType type); int32_t ReleaseOffloadPipe(AudioIOHandle id, uint32_t paIndex, OffloadType type); - void CheckOffloadStream(AudioStreamChangeInfo &streamChangeInfo); - void ReConfigOffloadStatus(uint32_t sessionId, std::shared_ptr &pipeInfo, std::string &oldSinkName); void PrepareMoveAttrs(std::shared_ptr &streamDesc, DeviceType &oldDeviceType, bool &isNeedTriggerCallback, std::string &oldSinkName, const AudioStreamDeviceChangeReasonExt reason); void MuteSinkPortForSwitchDevice(std::shared_ptr &streamDesc, @@ -479,6 +483,11 @@ private: void UpdateOffloadState(std::shared_ptr pipeInfo); void NotifyRouteUpdate(const std::vector> &streamDescs); void ResetNearlinkDeviceState(const std::shared_ptr &deviceDesc); + + // For offload + void CheckAndUpdateOffloadEnableForStream( + OffloadAction action, std::shared_ptr &streamDesc); + void WriteCapturerConcurrentEvent(const std::unique_ptr &result); void LogCapturerConcurrentResult(const std::unique_ptr &result); bool WriteCapturerConcurrentMsg(std::shared_ptr streamDesc, @@ -566,6 +575,8 @@ private: .descriptor = nullptr, .type = CAST_TYPE_NULL }; + std::unordered_map voiceMuteStateMap_; + std::shared_mutex muteMutex_; }; } } diff --git a/services/audio_policy/server/service/service_main/include/audio_policy_server.h b/services/audio_policy/server/service/service_main/include/audio_policy_server.h index 9146d009062d09f784c262764bc4e1aa91737700..796d5139269b313303ba4490645be053323373c4 100644 --- a/services/audio_policy/server/service/service_main/include/audio_policy_server.h +++ b/services/audio_policy/server/service/service_main/include/audio_policy_server.h @@ -539,8 +539,6 @@ public: int32_t UnsetAudioDeviceAnahsCallback() override; - int32_t MoveToNewPipe(uint32_t sessionId, int32_t pipeType) override; - int32_t InjectInterruption(const std::string &networkId, const InterruptEvent &event) override; int32_t SetInputDevice(int32_t deviceType, uint32_t sessionID, int32_t sourceType, bool isRunning) override; @@ -679,9 +677,14 @@ public: int32_t UpdateDeviceInfo(const std::shared_ptr &deviceDesc, int32_t command) override; int32_t SetSleAudioOperationCallback(const sptr &object) override; int32_t CallRingtoneLibrary(); + void SetVoiceMuteState(uint32_t sessionId, bool isMute); int32_t SetSystemVolumeDegree(int32_t streamType, int32_t volumeDegree, int32_t volumeFlag, int32_t uid) override; int32_t GetSystemVolumeDegree(int32_t streamType, int32_t uid, int32_t &volumeDegree) override; int32_t GetMinVolumeDegree(int32_t volumeType, int32_t &volumeDegree) override; +#ifdef FEATURE_MULTIMODALINPUT_INPUT + bool ReloadLoudVolumeMode(const AudioStreamType streamInFocus, + SetLoudVolMode setVolMode = LOUD_VOLUME_SWITCH_UNSET); +#endif protected: void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override; void RegisterParamCallback(); @@ -762,7 +765,6 @@ private: // Permission and privacy bool VerifyPermission(const std::string &permission, uint32_t tokenId = 0, bool isRecording = false); bool VerifyBluetoothPermission(); - int32_t OffloadStopPlaying(const AudioInterrupt &audioInterrupt); int32_t SetAudioSceneInternal(AudioScene audioScene, const int32_t uid = INVALID_UID, const int32_t pid = INVALID_PID); bool VerifySessionId(uint32_t sessionId, uint32_t clientUid); @@ -776,6 +778,10 @@ private: bool IsContinueAddVol(); void TriggerMuteCheck(); int32_t ProcessVolumeKeyEvents(const int32_t keyType); + void SetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool state); + bool ClearLoudVolumeHoldMap(FunctionHoldType funcHoldType); + bool GetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool &state); + bool CheckLoudVolumeMode(const int32_t volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); #endif void AddAudioServiceOnStart(); void SubscribeOsAccountChangeEvents(); @@ -864,6 +870,13 @@ private: std::mutex volUpHistoryMutex_; std::deque volUpHistory_; std::atomic hasSubscribedVolumeKeyEvents_ = false; + + int32_t triggerTime = 0; + int64_t upTriggerTimeMSec = 0; + std::mutex loudVolTrigTimeMutex_; + AudioStreamType lastReloadStreamType = STREAM_DEFAULT; + std::mutex setLoudVolHoldMutex_; + std::unordered_map loudVolumeHoldMap_; #endif std::vector clientDiedListenerState_; sptr powerStateListener_; @@ -881,6 +894,7 @@ private: bool volumeApplyToAll_ = false; bool screenOffAdjustVolumeEnable_ = false; bool supportVibrator_ = false; + bool loudVolumeModeEnable_ = false; bool isHighResolutionExist_ = false; std::mutex descLock_; diff --git a/services/audio_policy/server/service/service_main/include/audio_policy_service.h b/services/audio_policy/server/service/service_main/include/audio_policy_service.h index 6f2f18f69229d0124cbd7d796e355cbd9936d5d2..b634e93d3e7dac7c3f9a11120e1cd020752cfb3a 100644 --- a/services/audio_policy/server/service/service_main/include/audio_policy_service.h +++ b/services/audio_policy/server/service/service_main/include/audio_policy_service.h @@ -200,8 +200,6 @@ public: int32_t GetHardwareOutputSamplingRate(const std::shared_ptr &desc); - int32_t OffloadStopPlaying(const std::vector &sessionIds); - int32_t OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp); int32_t NearlinkGetRenderPosition(uint32_t &delayValue); @@ -220,7 +218,6 @@ public: void NotifyAccountsChanged(const int &id); - int32_t DynamicUnloadModule(const AudioPipeType pipeType); // for effect V3 int32_t GetSupportedAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray); int32_t SetAudioEffectProperty(const AudioEffectPropertyArrayV3 &propertyArray); @@ -318,8 +315,6 @@ private: void UnregisterBluetoothListener(); - int32_t OffloadStartPlaying(const std::vector &sessionIds); - BluetoothOffloadState GetA2dpOffloadFlag(); void SetDefaultAdapterEnable(bool isEnable); bool IsDevicePlaybackSupported(const AudioProcessConfig &config, const AudioDeviceDescriptor &deviceInfo); @@ -415,7 +410,6 @@ private: AudioDeviceLock& audioDeviceLock_; AudioDeviceStatus& audioDeviceStatus_; SleAudioDeviceManager& sleAudioDeviceManager_; - }; class SafeVolumeEventSubscriber : public EventFwk::CommonEventSubscriber { 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 7aba9e07f2271bd620e9cca464ec968588bd99b4..f0c7493c20b18caa1bbc8bdb0b856dd7b8bab45e 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 @@ -146,6 +146,8 @@ void AudioCoreService::DumpPipeManager(std::string &dumpString) if (pipeManager_ != nullptr) { pipeManager_->Dump(dumpString); } + + audioOffloadStream_.Dump(dumpString); } int32_t AudioCoreService::CreateRendererClient( @@ -167,10 +169,6 @@ int32_t AudioCoreService::CreateRendererClient( audioFlag = AUDIO_FLAG_NORMAL; AddSessionId(sessionId); pipeManager_->AddModemCommunicationId(sessionId, streamDesc); - } else if (streamDesc->rendererInfo_.streamUsage == STREAM_USAGE_RINGTONE || - streamDesc->rendererInfo_.streamUsage == STREAM_USAGE_VOICE_COMMUNICATION) { - std::string bundleName = AudioBundleManager::GetBundleNameFromUid(streamDesc->appInfo_.appUid); - Bluetooth::AudioHfpManager::AddVirtualCallBundleName(bundleName, streamDesc->sessionId_); } AUDIO_INFO_LOG("[DeviceFetchStart] for stream %{public}d", sessionId); @@ -224,7 +222,7 @@ int32_t AudioCoreService::CreateCapturerClient( AUDIO_INFO_LOG("[DeviceFetchInfo] device %{public}s for stream %{public}d", streamDesc->GetNewDevicesTypeString().c_str(), sessionId); - UpdateRecordStreamFlag(streamDesc); + UpdateRecordStreamInfo(streamDesc); AUDIO_INFO_LOG("Target audioFlag 0x%{public}x for stream %{public}d", streamDesc->audioFlag_, sessionId); @@ -297,6 +295,13 @@ bool AudioCoreService::IsForcedNormal(std::shared_ptr &st void AudioCoreService::UpdatePlaybackStreamFlag(std::shared_ptr &streamDesc, bool isCreateProcess) { CHECK_AND_RETURN_LOG(streamDesc, "Input param error"); + + if (isCreateProcess && streamDesc->rendererInfo_.forceToNormal) { + AUDIO_INFO_LOG("client force create normal"); + streamDesc->audioFlag_ = AUDIO_OUTPUT_FLAG_NORMAL; + return; + } + // fast/normal has done in audioRendererPrivate CHECK_AND_RETURN_LOG(IsForcedNormal(streamDesc) == false, "Forced normal cases"); @@ -322,8 +327,7 @@ void AudioCoreService::UpdatePlaybackStreamFlag(std::shared_ptrrendererInfo_.originalFlag) { case AUDIO_FLAG_MMAP: - streamDesc->audioFlag_ = - IsFastAllowed(streamDesc->bundleName_) ? AUDIO_OUTPUT_FLAG_FAST : AUDIO_OUTPUT_FLAG_NORMAL; + streamDesc->audioFlag_ = SetFlagForMmapStream(streamDesc); return; case AUDIO_FLAG_VOIP_FAST: streamDesc->audioFlag_ = @@ -338,6 +342,15 @@ void AudioCoreService::UpdatePlaybackStreamFlag(std::shared_ptraudioFlag_ = SetFlagForSpecialStream(streamDesc, isCreateProcess); } +AudioFlag AudioCoreService::SetFlagForMmapStream(std::shared_ptr &streamDesc) +{ + if (streamDesc->GetMainNewDeviceType() == DEVICE_TYPE_BLUETOOTH_A2DP || + IsFastAllowed(streamDesc->bundleName_)) { + return AUDIO_OUTPUT_FLAG_FAST; + } + return AUDIO_OUTPUT_FLAG_NORMAL; +} + AudioFlag AudioCoreService::SetFlagForSpecialStream(std::shared_ptr &streamDesc, bool isCreateProcess) { @@ -356,8 +369,19 @@ AudioFlag AudioCoreService::SetFlagForSpecialStream(std::shared_ptr streamDesc) +void AudioCoreService::UpdateRecordStreamInfo(std::shared_ptr &streamDesc) { + auto sourceStrategyMap = AudioSourceStrategyData::GetInstance().GetSourceStrategyMap(); + if (sourceStrategyMap != nullptr) { + auto strategyIt = sourceStrategyMap->find(streamDesc->capturerInfo_.sourceType); + if (strategyIt != sourceStrategyMap->end()) { + streamDesc->audioFlag_ = strategyIt->second.audioFlag; + AUDIO_INFO_LOG("sourceType: %{public}d, use audioFlag: %{public}u", + streamDesc->capturerInfo_.sourceType, strategyIt->second.audioFlag); + return; + } + } + if (streamDesc->capturerInfo_.originalFlag == AUDIO_FLAG_FORCED_NORMAL || streamDesc->capturerInfo_.capturerFlags == AUDIO_FLAG_FORCED_NORMAL) { streamDesc->audioFlag_ = AUDIO_INPUT_FLAG_NORMAL; @@ -391,8 +415,9 @@ void AudioCoreService::UpdateRecordStreamFlag(std::shared_ptraudioFlag_ = AUDIO_FLAG_NONE; + return; } void AudioCoreService::CheckAndSetCurrentOutputDevice(std::shared_ptr &desc, int32_t sessionId) @@ -450,6 +475,11 @@ int32_t AudioCoreService::StartClient(uint32_t sessionId) } CHECK_AND_RETURN_RET_LOG(!streamDesc->newDeviceDescs_.empty(), ERR_INVALID_PARAM, "newDeviceDescs_ is empty"); + + // Update a2dp offload flag for update active route, if a2dp offload flag is not true, audioserver + // will reset a2dp device to none. + audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForStartStream(static_cast(sessionId)); + if (streamDesc->audioMode_ == AUDIO_MODE_PLAYBACK) { int32_t outputRet = ActivateOutputDevice(streamDesc); CHECK_AND_RETURN_RET_LOG(outputRet == SUCCESS, outputRet, "Activate output device failed"); @@ -497,7 +527,7 @@ int32_t AudioCoreService::ReleaseClient(uint32_t sessionId, SessionOperationMsg return SUCCESS; } pipeManager_->RemoveClient(sessionId); - audioOffloadStream_.ResetOffloadStatus(sessionId); + audioOffloadStream_.UnsetOffloadStatus(sessionId); RemoveUnusedPipe(); if (opMsg == SESSION_OP_MSG_REMOVE_PIPE) { RemoveUnusedRecordPipe(); @@ -929,15 +959,6 @@ int32_t AudioCoreService::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo & return ret; // only update tracker in new and prepared } - const auto &rendererChangeInfo = streamChangeInfo.audioRendererChangeInfo; - if ((mode == AUDIO_MODE_PLAYBACK) && (rendererChangeInfo.rendererInfo.streamUsage == STREAM_USAGE_RINGTONE || - rendererChangeInfo.rendererInfo.streamUsage == STREAM_USAGE_VOICE_COMMUNICATION)) { - if ((rendererState == RENDERER_STOPPED ||rendererState == RENDERER_RELEASED || - rendererState == RENDERER_PAUSED)) { - Bluetooth::AudioHfpManager::DeleteVirtualCallStream(rendererChangeInfo.sessionId); - } - } - UpdateTracker(mode, streamChangeInfo, rendererState); if (audioA2dpOffloadManager_) { @@ -947,7 +968,9 @@ int32_t AudioCoreService::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo & SendA2dpConnectedWhileRunning(rendererState, streamChangeInfo.audioRendererChangeInfo.sessionId); if (mode == AUDIO_MODE_PLAYBACK) { - CheckOffloadStream(streamChangeInfo); + audioOffloadStream_.UpdateOffloadStatusFromUpdateTracker( + streamChangeInfo.audioRendererChangeInfo.sessionId, + streamChangeInfo.audioRendererChangeInfo.rendererState); } return ret; } @@ -980,9 +1003,9 @@ bool AudioCoreService::ConnectServiceAdapter() return audioPolicyManager_.ConnectServiceAdapter(); } -void AudioCoreService::OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName) +void AudioCoreService::OnReceiveUpdateDeviceNameEvent(const std::string macAddress, const std::string deviceName) { - audioDeviceManager_.OnReceiveBluetoothEvent(macAddress, deviceName); + audioDeviceManager_.OnReceiveUpdateDeviceNameEvent(macAddress, deviceName); audioConnectedDevice_.SetDisplayName(macAddress, deviceName); } @@ -1272,7 +1295,7 @@ int32_t AudioCoreService::FetchInputDeviceAndRoute(std::string caller) AUDIO_INFO_LOG("[DeviceFetchInfo] device %{public}s for stream %{public}d with status %{public}u", streamDesc->GetNewDevicesTypeString().c_str(), streamDesc->sessionId_, streamDesc->streamStatus_); - UpdateRecordStreamFlag(streamDesc); + UpdateRecordStreamInfo(streamDesc); if (!HandleInputStreamInRunning(streamDesc)) { continue; } diff --git a/services/audio_policy/server/service/service_main/src/audio_core_service_entry.cpp b/services/audio_policy/server/service/service_main/src/audio_core_service_entry.cpp index 71cadad6cdea863bfad375c7c4cb7f71af4c80c5..158452acf8b1d88a024508ea48edddd4c5e2522a 100644 --- a/services/audio_policy/server/service/service_main/src/audio_core_service_entry.cpp +++ b/services/audio_policy/server/service/service_main/src/audio_core_service_entry.cpp @@ -137,6 +137,16 @@ uint32_t AudioCoreService::EventEntry::GenerateSessionId() return coreService_->GenerateSessionId(); } +void AudioCoreService::EventEntry::GetVoiceMuteState(uint32_t sessionId, bool &muteState) +{ + return coreService_->GetVoiceMuteState(sessionId, muteState); +} + +void AudioCoreService::EventEntry::RemoveVoiceMuteState(uint32_t sessionId) +{ + return coreService_->RemoveVoiceMuteState(sessionId); +} + int32_t AudioCoreService::EventEntry::SetDefaultOutputDevice(const DeviceType deviceType, const uint32_t sessionID, const StreamUsage streamUsage, bool isRunning, bool skipForce) { @@ -297,6 +307,13 @@ int32_t AudioCoreService::EventEntry::FetchOutputDeviceAndRoute(std::string call return coreService_->FetchOutputDeviceAndRoute(caller, reason); } +int32_t AudioCoreService::EventEntry::FetchInputDeviceAndRoute(std::string caller) +{ + CHECK_AND_RETURN_RET(coreService_ != nullptr, ERR_UNKNOWN); + std::lock_guard lock(eventMutex_); + return coreService_->FetchInputDeviceAndRoute(caller); +} + std::shared_ptr AudioCoreService::EventEntry::GetActiveBluetoothDevice() { std::shared_lock lock(eventMutex_); @@ -323,12 +340,6 @@ int32_t AudioCoreService::EventEntry::SetCallDeviceActive( return SUCCESS; } -std::vector> AudioCoreService::EventEntry::GetAvailableDevices(AudioDeviceUsage usage) -{ - std::shared_lock lock(eventMutex_); - return coreService_->GetAvailableDevices(usage); -} - int32_t AudioCoreService::EventEntry::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo, const sptr &object, const int32_t apiVersion) { @@ -373,10 +384,11 @@ vector> AudioCoreService::EventEntry::GetAudioCapture return coreService_->GetAudioCapturerMicrophoneDescriptors(sessionId); } -void AudioCoreService::EventEntry::OnReceiveBluetoothEvent(const std::string macAddress, const std::string deviceName) +void AudioCoreService::EventEntry::OnReceiveUpdateDeviceNameEvent(const std::string macAddress, + const std::string deviceName) { std::lock_guard lock(eventMutex_); - coreService_->OnReceiveBluetoothEvent(macAddress, deviceName); + coreService_->OnReceiveUpdateDeviceNameEvent(macAddress, deviceName); } int32_t AudioCoreService::EventEntry::SelectOutputDevice(sptr audioRendererFilter, 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 825750716886733b12045f8fe7f0205560dbfa36..3ac5fa459a5bb673d94282416a3ac57ac23c5ce8 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 @@ -86,7 +86,8 @@ static const std::vector SourceNames = { std::string(USB_MIC), std::string(PRIMARY_WAKEUP), std::string(FILE_SOURCE), - std::string(ACCESSORY_SOURCE) + std::string(ACCESSORY_SOURCE), + std::string(PRIMARY_AI_MIC) }; std::string AudioCoreService::GetEncryptAddr(const std::string &addr) @@ -114,6 +115,7 @@ void AudioCoreService::UpdateActiveDeviceAndVolumeBeforeMoveSession( for (std::shared_ptr streamDesc : streamDescs) { // if streamDesc select bluetooth or headset, active it if (!HandleOutputStreamInRunning(streamDesc, reason)) { + UpdatePlaybackStreamFlag(streamDesc, false); continue; } int32_t outputRet = ActivateOutputDevice(streamDesc, reason); @@ -155,6 +157,23 @@ void AudioCoreService::UpdateOffloadState(std::shared_ptr pipeInf offloadCloseCondition_[type].notify_all(); } +void AudioCoreService::CheckAndUpdateOffloadEnableForStream( + OffloadAction action, std::shared_ptr &streamDesc) +{ + if (action == OFFLOAD_NEW || action == OFFLOAD_MOVE_IN) { + // Check stream is offload and then set + if (streamDesc->IsRouteOffload()) { + OffloadAdapter adapter = (streamDesc->IsDeviceRemote() ? OFFLOAD_IN_REMOTE : OFFLOAD_IN_PRIMARY); + audioOffloadStream_.SetOffloadStatus(adapter, streamDesc->GetSessionId()); + } + } else { + // Check stream is moved from offload and then unset + if (streamDesc->IsRouteNormal() && (streamDesc->IsOldRouteOffload())) { + audioOffloadStream_.UnsetOffloadStatus(streamDesc->GetSessionId()); + } + } +} + void AudioCoreService::NotifyRouteUpdate(const std::vector> &streamDescs) { for (auto &streamDesc : streamDescs) { @@ -177,6 +196,10 @@ int32_t AudioCoreService::FetchRendererPipesAndExecute( AUDIO_INFO_LOG("[PipeFetchStart] all %{public}zu output streams", streamDescs.size()); UpdateActiveDeviceAndVolumeBeforeMoveSession(streamDescs, reason); std::vector> pipeInfos = audioPipeSelector_->FetchPipesAndExecute(streamDescs); + + // Update a2dp offload flag here because UpdateActiveRoute() need actual flag. + audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForAllStream(); + uint32_t audioFlag; for (auto &pipeInfo : pipeInfos) { CHECK_AND_CONTINUE_LOG(pipeInfo != nullptr, "pipeInfo is nullptr"); @@ -309,7 +332,7 @@ int32_t AudioCoreService::UpdateModemRoute(std::vectordeviceType_, DeviceFlag::OUTPUT_DEVICES_FLAG, - descs.front()->deviceName_, descs.front()->networkId_); + descs.front()->deviceName_, LOCAL_NETWORK_ID); audioVolumeManager_.SetVoiceCallVolume(GetSystemVolumeLevel(STREAM_VOICE_CALL)); } AudioDeviceDescriptor desc = AudioDeviceDescriptor(descs.front()); @@ -488,7 +511,11 @@ int32_t AudioCoreService::BluetoothDeviceFetchOutputHandle(shared_ptr desc = streamDesc->newDeviceDescs_.front(); CHECK_AND_RETURN_RET_LOG(desc != nullptr, BLUETOOTH_FETCH_RESULT_CONTINUE, "Device desc is nullptr"); + ResetNearlinkDeviceState(desc); + if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) { + std::string sinkPort = AudioPolicyUtils::GetInstance().GetSinkPortName(DEVICE_TYPE_BLUETOOTH_A2DP); + audioPolicyManager_.SuspendAudioDevice(sinkPort, false); int32_t ret = ActivateA2dpDeviceWhenDescEnabled(desc, reason); if (ret != SUCCESS) { AUDIO_ERR_LOG("Activate a2dp [%{public}s] failed", encryptMacAddr.c_str()); @@ -829,14 +856,17 @@ void AudioCoreService::ProcessOutputPipeNew(std::shared_ptr pipeI desc->sessionId_, desc->streamAction_, pipeInfo->name_.c_str()); switch (desc->streamAction_) { case AUDIO_STREAM_ACTION_NEW: + CheckAndUpdateOffloadEnableForStream(OFFLOAD_NEW, desc); flag = desc->routeFlag_; break; case AUDIO_STREAM_ACTION_MOVE: + CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_OUT, desc); if (desc->streamStatus_ != STREAM_STATUS_STARTED) { MoveStreamSink(desc, pipeInfo, reason); } else { MoveToNewOutputDevice(desc, pipeInfo, reason); } + CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_IN, desc); break; case AUDIO_STREAM_ACTION_RECREATE: TriggerRecreateRendererStreamCallback(desc, reason); @@ -857,15 +887,18 @@ void AudioCoreService::ProcessOutputPipeUpdate(std::shared_ptr pi desc->sessionId_, desc->streamAction_, pipeInfo->name_.c_str()); switch (desc->streamAction_) { case AUDIO_STREAM_ACTION_NEW: + CheckAndUpdateOffloadEnableForStream(OFFLOAD_NEW, desc); flag = desc->routeFlag_; break; case AUDIO_STREAM_ACTION_DEFAULT: case AUDIO_STREAM_ACTION_MOVE: + CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_OUT, desc); if (desc->streamStatus_ != STREAM_STATUS_STARTED) { MoveStreamSink(desc, pipeInfo, reason); } else { MoveToNewOutputDevice(desc, pipeInfo, reason); } + CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_IN, desc); break; case AUDIO_STREAM_ACTION_RECREATE: TriggerRecreateRendererStreamCallback(desc, reason); @@ -973,7 +1006,8 @@ void AudioCoreService::ProcessInputPipeUpdate(std::shared_ptr pip void AudioCoreService::RemoveUnusedPipe() { - std::vector> pipeInfos = pipeManager_->GetUnusedPipe(); + DeviceType curOutputDeviceType = audioActiveDevice_.GetCurrentOutputDeviceType(); + std::vector> pipeInfos = pipeManager_->GetUnusedPipe(curOutputDeviceType); for (auto pipeInfo : pipeInfos) { CHECK_AND_CONTINUE_LOG(pipeInfo != nullptr, "pipeInfo is nullptr"); AUDIO_INFO_LOG("[PipeExecInfo] Remove and close Pipe %{public}s", pipeInfo->ToString().c_str()); @@ -1025,6 +1059,35 @@ uint32_t AudioCoreService::GenerateSessionId() return AudioStreamIdAllocator::GetAudioStreamIdAllocator().GenerateStreamId(); } +void AudioCoreService::SetVoiceMuteState(uint32_t sessionId, bool isMute) +{ + std::unique_lock lock(muteMutex_); + voiceMuteStateMap_[sessionId] = isMute; + AUDIO_INFO_LOG("set mute state for session %{public}u to %{public}s", sessionId, isMute ? "muted" : "unmuted"); +} + +void AudioCoreService::GetVoiceMuteState(uint32_t sessionId, bool &muteState) +{ + std::shared_lock lock(muteMutex_); + auto it = voiceMuteStateMap_.find(sessionId); + if (it != voiceMuteStateMap_.end()) { + muteState = it->second; + return; + } + + muteState = false; +} + +void AudioCoreService::RemoveVoiceMuteState(uint32_t sessionId) +{ + std::unique_lock lock(muteMutex_); + auto it = voiceMuteStateMap_.find(sessionId); + if (it != voiceMuteStateMap_.end()) { + AUDIO_INFO_LOG("remove mute state for session %{public}u", sessionId); + voiceMuteStateMap_.erase(it); + } +} + void AudioCoreService::AddSessionId(const uint32_t sessionId) { uid_t callingUid = static_cast(IPCSkeleton::GetCallingUid()); @@ -1179,14 +1242,6 @@ void AudioCoreService::MoveToNewOutputDevice(std::shared_ptrsessionId_, callbackDesc, reason); } - // Mute(MuteSinkPortForSwitchDevice) is not effective before new port opened (OpenNewAudioPortAndRoute), - // But anco application need more time(1S) to STOP after receive 'KEYCODE_MEDIA_PAUSE' event, - // So, once the audio stream switches from the old sinkport to the new sinkport before the application STOP, - // there will be audio leakage. So try Mute again for anco. - if (streamDesc->appInfo_.appUid == AUDIO_ID) { - MuteSinkPortForSwitchDevice(streamDesc, reason); - } - SleepForSwitchDevice(streamDesc, reason); CHECK_AND_RETURN_LOG(IsNewDevicePlaybackSupported(streamDesc), "new device not support playback"); @@ -1207,7 +1262,6 @@ void AudioCoreService::MoveToNewOutputDevice(std::shared_ptrsessionId_, pipeInfo, oldSinkName); audioIOHandleMap_.NotifyUnmutePort(); } @@ -1303,7 +1357,7 @@ void AudioCoreService::MoveStreamSource(std::shared_ptr s // MoveSourceOuputByIndexName auto ret = (streamDesc->newDeviceDescs_.front()->networkId_ == LOCAL_NETWORK_ID) - ? MoveToLocalInputDevice(targetSourceOutputs, streamDesc->newDeviceDescs_.front()) + ? MoveToLocalInputDevice(targetSourceOutputs, streamDesc->newDeviceDescs_.front(), streamDesc->routeFlag_) : MoveToRemoteInputDevice(targetSourceOutputs, streamDesc->newDeviceDescs_.front()); CHECK_AND_RETURN_LOG((ret == SUCCESS), "Move source output %{public}d to device %{public}d failed!", streamDesc->sessionId_, streamDesc->newDeviceDescs_.front()->deviceType_); @@ -1329,7 +1383,7 @@ void AudioCoreService::MoveToNewInputDevice(std::shared_ptrnewDeviceDescs_.front()->networkId_ == LOCAL_NETWORK_ID) - ? MoveToLocalInputDevice(targetSourceOutputs, streamDesc->newDeviceDescs_.front()) + ? MoveToLocalInputDevice(targetSourceOutputs, streamDesc->newDeviceDescs_.front(), streamDesc->routeFlag_) : MoveToRemoteInputDevice(targetSourceOutputs, streamDesc->newDeviceDescs_.front()); CHECK_AND_RETURN_LOG((ret == SUCCESS), "Move source output %{public}d to device %{public}d failed!", streamDesc->sessionId_, streamDesc->newDeviceDescs_.front()->deviceType_); @@ -1346,13 +1400,14 @@ void AudioCoreService::MoveToNewInputDevice(std::shared_ptr sourceOutputs, - std::shared_ptr localDeviceDescriptor) + std::shared_ptr localDeviceDescriptor, uint32_t routeFlag) { CHECK_AND_RETURN_RET_LOG(LOCAL_NETWORK_ID == localDeviceDescriptor->networkId_, ERR_INVALID_OPERATION, "failed: not a local device."); uint32_t sourceId = -1; // invalid source id, use source name instead. - std::string sourceName = AudioPolicyUtils::GetInstance().GetSourcePortName(localDeviceDescriptor->deviceType_); + std::string sourceName = AudioPolicyUtils::GetInstance().GetSourcePortName(localDeviceDescriptor->deviceType_, + routeFlag); for (size_t i = 0; i < sourceOutputs.size(); i++) { int32_t ret = audioPolicyManager_.MoveSourceOutputByIndexOrName(sourceOutputs[i].paStreamId, sourceId, sourceName); @@ -1788,15 +1843,17 @@ uint32_t AudioCoreService::OpenNewAudioPortAndRoute(std::shared_ptrrouteFlag_); + if ((audioActiveDevice_.GetCurrentInputDeviceType() == DEVICE_TYPE_MIC || + audioActiveDevice_.GetCurrentInputDeviceType() == DEVICE_TYPE_ACCESSORY) && + (pipeInfo->routeFlag_ != AUDIO_INPUT_FLAG_AI)) { audioPolicyManager_.SetDeviceActive(audioActiveDevice_.GetCurrentInputDeviceType(), pipeInfo->moduleInfo_.name, true, INPUT_DEVICES_FLAG); } } - CHECK_AND_RETURN_RET_LOG(id != HDI_INVALID_ID, ERR_INVALID_HANDLE, + CHECK_AND_RETURN_RET_LOG(id != HDI_INVALID_ID, OPEN_PORT_FAILURE, "OpenAudioPort failed ioHandle[%{public}u]", id); - CHECK_AND_RETURN_RET_LOG(paIndex != OPEN_PORT_FAILURE, ERR_OPERATION_FAILED, + CHECK_AND_RETURN_RET_LOG(paIndex != OPEN_PORT_FAILURE, OPEN_PORT_FAILURE, "OpenAudioPort failed paId[%{public}u]", paIndex); audioIOHandleMap_.AddIOHandleInfo(pipeInfo->moduleInfo_.name, id); AUDIO_INFO_LOG("[PipeExecInfo] Get HDI id: %{public}u, paIndex %{public}u", id, paIndex); @@ -1982,10 +2039,6 @@ float AudioCoreService::GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t bool AudioCoreService::IsStreamSupportLowpower(std::shared_ptr streamDesc) { Trace trace("IsStreamSupportLowpower"); - if (pipeManager_->PcmOffloadSessionCount() > 0) { - AUDIO_INFO_LOG("PIPE_TYPE_OFFLOAD already exist."); - return false; - } if (!streamDesc->rendererInfo_.isOffloadAllowed) { AUDIO_INFO_LOG("normal stream because renderInfo not support offload."); return false; @@ -2358,35 +2411,6 @@ int32_t AudioCoreService::ReleaseOffloadPipe(AudioIOHandle id, uint32_t paIndex, return GetEventEntry()->ReleaseOffloadPipe(id, paIndex, type); } -void AudioCoreService::CheckOffloadStream(AudioStreamChangeInfo &streamChangeInfo) -{ - std::string adapterName = GetAdapterNameBySessionId(streamChangeInfo.audioRendererChangeInfo.sessionId); - AUDIO_INFO_LOG("session: %{public}u, adapter name: %{public}s", - streamChangeInfo.audioRendererChangeInfo.sessionId, adapterName.c_str()); - CHECK_AND_RETURN(adapterName == OFFLOAD_PRIMARY_SPEAKER || adapterName.find("_out_offload") != std::string::npos); - - if (streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_PAUSED || - streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_STOPPED || - streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_RELEASED) { - audioOffloadStream_.ResetOffloadStatus(streamChangeInfo.audioRendererChangeInfo.sessionId); - } - if (streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_RUNNING) { - audioOffloadStream_.SetOffloadStatus(streamChangeInfo.audioRendererChangeInfo.sessionId); - } -} - -void AudioCoreService::ReConfigOffloadStatus(uint32_t sessionId, - std::shared_ptr &pipeInfo, std::string &oldSinkName) -{ - AUDIO_INFO_LOG("new sink: %{public}s, old sink: %{public}s, sessionId: %{public}u", - pipeInfo->moduleInfo_.name.c_str(), oldSinkName.c_str(), sessionId); - if (pipeInfo->moduleInfo_.name == OFFLOAD_PRIMARY_SPEAKER || pipeInfo->moduleInfo_.className == "remote_offload") { - audioOffloadStream_.SetOffloadStatus(sessionId); - } else if (oldSinkName == OFFLOAD_PRIMARY_SPEAKER) { - audioOffloadStream_.ResetOffloadStatus(sessionId); - } -} - void AudioCoreService::PrepareMoveAttrs(std::shared_ptr &streamDesc, DeviceType &oldDeviceType, bool &isNeedTriggerCallback, std::string &oldSinkName, const AudioStreamDeviceChangeReasonExt reason) { @@ -2748,7 +2772,7 @@ void AudioCoreService::ResetNearlinkDeviceState(const std::shared_ptrdeviceType_ == DEVICE_TYPE_NEARLINK && currentOutputDevice.deviceType_ == DEVICE_TYPE_NEARLINK) { + if (deviceDesc->deviceRole_ == OUTPUT_DEVICE && currentOutputDevice.deviceType_ == DEVICE_TYPE_NEARLINK) { if (!deviceDesc->IsSameDeviceDesc(currentOutputDevice)) { AUDIO_INFO_LOG("Reset nearlink output device state, macAddress: %{public}s", AudioPolicyUtils::GetInstance().GetEncryptAddr(currentOutputDevice.macAddress_).c_str()); @@ -2756,8 +2780,7 @@ void AudioCoreService::ResetNearlinkDeviceState(const std::shared_ptr(currentOutputDevice)); } } - if (deviceDesc->deviceType_ == DEVICE_TYPE_NEARLINK_IN && - currentInputDevice.deviceType_ == DEVICE_TYPE_NEARLINK_IN) { + if (deviceDesc->deviceRole_ == INPUT_DEVICE && currentInputDevice.deviceType_ == DEVICE_TYPE_NEARLINK_IN) { if (!deviceDesc->IsSameDeviceDesc(currentInputDevice)) { AUDIO_INFO_LOG("Reset nearlink input device state, macAddress: %{public}s", AudioPolicyUtils::GetInstance().GetEncryptAddr(currentInputDevice.macAddress_).c_str()); @@ -2793,7 +2816,12 @@ int32_t AudioCoreService::ActivateNearlinkDevice(const std::shared_ptr LOUD_VOL_STREAM_TYPE_ENABLE = { + {STREAM_VOICE_CALL, FUNCTION_HOLD_SYSTEM}, + {STREAM_MUSIC, FUNCTION_HOLD_MUSIC}, + {STREAM_MEDIA, FUNCTION_HOLD_MUSIC}, + {STREAM_MOVIE, FUNCTION_HOLD_MUSIC}, + {STREAM_GAME, FUNCTION_HOLD_MUSIC}, + {STREAM_SPEECH, FUNCTION_HOLD_MUSIC}, + {STREAM_VOICE_MESSAGE, FUNCTION_HOLD_MUSIC}, + {STREAM_NAVIGATION, FUNCTION_HOLD_MUSIC}, + {STREAM_SOURCE_VOICE_CALL, FUNCTION_HOLD_SYSTEM}, + {STREAM_VOICE_COMMUNICATION, FUNCTION_HOLD_SYSTEM}, +}; + +bool FindLoudVolStreamTypeEnable(AudioStreamType streamType, FunctionHoldType &funcHoldType) +{ + auto iter = LOUD_VOL_STREAM_TYPE_ENABLE.find(streamType); + if (iter != LOUD_VOL_STREAM_TYPE_ENABLE.end()) { + funcHoldType = iter->second; + return true; + } + return false; +} + +void AudioPolicyServer::SetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool state) +{ + std::lock_guard lock(setLoudVolHoldMutex_); + loudVolumeHoldMap_[funcHoldType] = state; +} + +bool AudioPolicyServer::ClearLoudVolumeHoldMap(FunctionHoldType funcHoldType) +{ + std::lock_guard lock(setLoudVolHoldMutex_); + auto it = loudVolumeHoldMap_.find(funcHoldType); + if (it != loudVolumeHoldMap_.end()) { + loudVolumeHoldMap_.erase(it); + return true; + } + return false; +} + +bool AudioPolicyServer::GetLoudVolumeHoldMap(FunctionHoldType funcHoldType, bool &state) +{ + std::lock_guard lock(setLoudVolHoldMutex_); + if (loudVolumeHoldMap_.count(funcHoldType) > 0) { + state = loudVolumeHoldMap_[funcHoldType]; + return true; + } + return false; +} + +bool AudioPolicyServer::ReloadLoudVolumeMode(const AudioStreamType streamInFocus, SetLoudVolMode setVolMode) +{ + if (!loudVolumeModeEnable_) { + return false; + } + FunctionHoldType funcHoldType = FUNCTION_HOLD_INVALID; + if (false == FindLoudVolStreamTypeEnable(streamInFocus, funcHoldType) || + (audioActiveDevice_.GetCurrentOutputDeviceType() != DeviceType::DEVICE_TYPE_SPEAKER)) { + audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_MUSIC, false); + audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_SYSTEM, false); + AUDIO_INFO_LOG("streamType = %{public}d, or deviceType = %{public}d not support loud volume mode.", + streamInFocus, audioActiveDevice_.GetCurrentOutputDeviceType()); + return false; + } + if (lastReloadStreamType != streamInFocus) { + if (FUNCTION_HOLD_SYSTEM == funcHoldType) { + audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_MUSIC, false); + } else if (FUNCTION_HOLD_MUSIC == funcHoldType) { + audioVolumeManager_.SendLoudVolumeMode(FUNCTION_HOLD_SYSTEM, false); + ClearLoudVolumeHoldMap(FUNCTION_HOLD_SYSTEM); + } + } + + if (setVolMode == LOUD_VOLUME_SWITCH_ON) { + if (FUNCTION_HOLD_MUSIC == funcHoldType) { + SetLoudVolumeHoldMap(funcHoldType, true); + } else if (FUNCTION_HOLD_SYSTEM == funcHoldType) { + SetLoudVolumeHoldMap(funcHoldType, false); + } + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, true, true); + } else if (setVolMode == LOUD_VOLUME_SWITCH_OFF) { + ClearLoudVolumeHoldMap(funcHoldType); + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, false); + } else if (setVolMode == LOUD_VOLUME_SWITCH_UNSET) { + bool isHolding = false; + bool ret = GetLoudVolumeHoldMap(funcHoldType, isHolding); + if (ret && isHolding) { + audioVolumeManager_.SendLoudVolumeMode(funcHoldType, true); + } else { + AUDIO_INFO_LOG("no need load loud volume mode"); + } + } else { + AUDIO_ERR_LOG("setVolMode error : %{public}d", setVolMode); + return false; + } + + return true; +} + +bool AudioPolicyServer::CheckLoudVolumeMode(const int32_t volLevel, + const int32_t keyType, const AudioStreamType &streamInFocus) +{ + std::lock_guard lock(loudVolTrigTimeMutex_); + constexpr int32_t MAX_TRIGGER_TIMES = 2; + constexpr int32_t ENABLE_TRIGGER_TIMES = 1; + constexpr int32_t MAX_LOUD_VOLUME_MSEC = 3000; + constexpr int32_t MIN_LOUD_VOLUME_MSEC = 400; + bool isHolding = false; + FunctionHoldType funcHoldType = FUNCTION_HOLD_INVALID; + if (!loudVolumeModeEnable_ && !FindLoudVolStreamTypeEnable(streamInFocus, funcHoldType)) { + return false; + } + + struct timeval tv; + struct timezone tz; + gettimeofday(&tv, &tz); + int64_t mSec = static_cast(tv.tv_sec * 1000 + tv.tv_usec / AUDIO_MS_PER_SECOND); + + int32_t volumeLevelMax = -1; + int32_t streamInFocusInt = static_cast(streamInFocus); + GetMaxVolumeLevel(streamInFocusInt, volumeLevelMax); + int32_t volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? volLevel + 1 : volLevel - 1; + if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP && (volumeLevelInInt >= volumeLevelMax)) { + if (GetLoudVolumeHoldMap(funcHoldType, isHolding)) { + AUDIO_DEBUG_LOG("no need to repeatedly set loud volume mode."); + return false; + } + if (triggerTime == MAX_TRIGGER_TIMES && mSec - upTriggerTimeMSec < MAX_LOUD_VOLUME_MSEC) { + triggerTime = 0; + bool ret = ReloadLoudVolumeMode(streamInFocus, LOUD_VOLUME_SWITCH_ON); + CHECK_AND_RETURN_RET_LOG(ret != false, false, "set LoudVolume on error"); + lastReloadStreamType = streamInFocus; + return true; + } else if (triggerTime == ENABLE_TRIGGER_TIMES && (mSec - upTriggerTimeMSec < MAX_LOUD_VOLUME_MSEC) && + (mSec - upTriggerTimeMSec > MIN_LOUD_VOLUME_MSEC)) { + triggerTime++; + } else { + triggerTime = ENABLE_TRIGGER_TIMES; + } + upTriggerTimeMSec = mSec; + } else if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN && GetLoudVolumeHoldMap(funcHoldType, isHolding)) { + upTriggerTimeMSec = mSec; + triggerTime = ENABLE_TRIGGER_TIMES; + bool ret = ReloadLoudVolumeMode(streamInFocus, LOUD_VOLUME_SWITCH_OFF); + CHECK_AND_RETURN_RET_LOG(ret != false, false, "set LoudVolume off error"); + return true; + } else { + upTriggerTimeMSec = 0; + triggerTime = 0; + } + return false; +} +#endif + void AudioPolicyServer::ChangeVolumeOnVoiceAssistant(AudioStreamType &streamInFocus) { if (streamInFocus == AudioStreamType::STREAM_VOICE_ASSISTANT && @@ -584,14 +739,23 @@ int32_t AudioPolicyServer::ProcessVolumeKeyEvents(const int32_t keyType) int32_t AudioPolicyServer::SetVolumeInternalByKeyEvent(AudioStreamType streamInFocus, int32_t zoneId, const int32_t keyType) { + bool updateVol = true; int32_t volumeLevelInInt = GetSystemVolumeLevelInternal(streamInFocus, zoneId); - if (MaxOrMinVolumeOption(volumeLevelInInt, keyType, streamInFocus)) { + if (audioActiveDevice_.GetCurrentOutputDeviceType() == DeviceType::DEVICE_TYPE_SPEAKER && + CheckLoudVolumeMode(volumeLevelInInt, keyType, streamInFocus)) { + updateVol = false; + AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", + audioActiveDevice_.GetCurrentOutputDeviceType(), streamInFocus); + } else if (MaxOrMinVolumeOption(volumeLevelInInt, keyType, streamInFocus)) { AUDIO_ERR_LOG("device %{public}d, stream %{public}d, volumelevel %{public}d invalid", audioActiveDevice_.GetCurrentOutputDeviceType(), streamInFocus, volumeLevelInInt); return ERROR_INVALID_PARAM; } - volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? ++volumeLevelInInt : --volumeLevelInInt; + if (updateVol) { + volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) + ? ++volumeLevelInInt : --volumeLevelInInt; + } int32_t ret = SetSystemVolumeLevelInternal(streamInFocus, volumeLevelInInt, true, zoneId); if (ret == ERR_SET_VOL_FAILED_BY_VOLUME_CONTROL_DISABLED) { SendVolumeKeyEventCbWithUpdateUiOrNot(streamInFocus, true); @@ -830,6 +994,7 @@ void AudioPolicyServer::SubscribeCommonEventExecute() SubscribeCommonEvent("usual.event.DATA_SHARE_READY"); SubscribeCommonEvent("usual.event.dms.rotation_changed"); SubscribeCommonEvent("usual.event.bluetooth.remotedevice.NAME_UPDATE"); + SubscribeCommonEvent("usual.event.nearlink.remotedevice.NAME_UPDATE"); SubscribeCommonEvent("usual.event.SCREEN_ON"); SubscribeCommonEvent("usual.event.SCREEN_OFF"); SubscribeCommonEvent("usual.event.SCREEN_LOCKED"); @@ -887,10 +1052,11 @@ void AudioPolicyServer::OnReceiveEvent(const EventFwk::CommonEventData &eventDat uint32_t rotate = static_cast(want.GetIntParam("rotation", 0)); AUDIO_INFO_LOG("Set rotation to audioeffectchainmanager is %{public}d", rotate); AudioServerProxy::GetInstance().SetRotationToEffectProxy(rotate); - } else if (action == "usual.event.bluetooth.remotedevice.NAME_UPDATE") { + } else if (action == "usual.event.bluetooth.remotedevice.NAME_UPDATE" || + action == "usual.event.nearlink.remotedevice.NAME_UPDATE") { std::string deviceName = want.GetStringParam("remoteName"); std::string macAddress = want.GetStringParam("deviceAddr"); - eventEntry_->OnReceiveBluetoothEvent(macAddress, deviceName); + eventEntry_->OnReceiveUpdateDeviceNameEvent(macAddress, deviceName); } else if (action == "usual.event.SCREEN_ON") { AUDIO_INFO_LOG("receive SCREEN_ON action, control audio focus if need"); audioDeviceCommon_.SetFirstScreenOn(); @@ -1532,6 +1698,18 @@ int32_t AudioPolicyServer::SetSystemVolumeLevelInternal(AudioStreamType streamTy return ERR_OPERATION_FAILED; } bool mute = GetStreamMuteInternal(streamType, zoneId); + int32_t volumeLevelMax = -1; + GetMaxVolumeLevel(static_cast(streamType), volumeLevelMax); + int32_t deviceType = audioActiveDevice_.GetCurrentOutputDeviceType(); + if (loudVolumeModeEnable_ && (mute || (isUpdateUi == false && deviceType == DeviceType::DEVICE_TYPE_SPEAKER))) { + int32_t keyCode = (volumeLevelMax > volumeLevel) ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN + : OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; + keyCode = mute ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN : keyCode; + if (CheckLoudVolumeMode(volumeLevel, keyCode, streamType)) { + AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", + deviceType, streamType); + } + } if (streamType == STREAM_ALL) { for (auto audioStreamType : GET_STREAM_ALL_VOLUME_TYPES) { AUDIO_INFO_LOG("SetVolume of STREAM_ALL, SteamType = %{public}d, mute = %{public}d, level = %{public}d", @@ -1558,6 +1736,17 @@ int32_t AudioPolicyServer::SetSystemVolumeLevelWithDeviceInternal(AudioStreamTyp AUDIO_ERR_LOG("Unadjustable device, not allow set volume"); return ERR_OPERATION_FAILED; } + + int32_t volumeLevelMax = -1; + GetMaxVolumeLevel(static_cast(streamType), volumeLevelMax); + if (loudVolumeModeEnable_ && isUpdateUi == false && deviceType == DeviceType::DEVICE_TYPE_SPEAKER) { + int32_t keyCode = (volumeLevelMax > volumeLevel) ? OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN + : OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; + if (CheckLoudVolumeMode(volumeLevel, keyCode, streamType)) { + AUDIO_INFO_LOG("device %{public}d, stream %{public}d, loud volume mode operation", + deviceType, streamType); + } + } return SetSingleStreamVolumeWithDevice(streamType, volumeLevel, isUpdateUi, deviceType); } @@ -1822,9 +2011,9 @@ int32_t AudioPolicyServer::GetExcludedDevices(int32_t audioDevUsageIn, device = audioDeviceLock_.GetExcludedDevices(audioDevUsage); int32_t apiVersion = HasUsbDevice(device) ? GetApiTargetVersion() : 0; + AudioDeviceDescriptor::ClientInfo clientInfo { apiVersion }; for (auto &desc : device) { CHECK_AND_RETURN_RET_LOG(desc, ERR_MEMORY_ALLOC_FAILED, "nullptr"); - auto clientInfo = std::make_shared(apiVersion); desc->SetClientInfo(clientInfo); } return SUCCESS; @@ -2270,6 +2459,7 @@ int32_t AudioPolicyServer::SetMicrophoneMutePersistent(bool isMute, int32_t type bool hasPermission = VerifyPermission(MICROPHONE_CONTROL_PERMISSION); CHECK_AND_RETURN_RET_LOG(hasPermission, ERR_PERMISSION_DENIED, "MICROPHONE_CONTROL_PERMISSION permission denied"); + CHECK_AND_RETURN_RET_LOG(POLICY_TYPE_MAP.count(type), ERR_OPERATION_FAILED, "type invalid"); WatchTimeout guard("PrivacyKit::SetMutePolicy:SetMicrophoneMutePersistent"); bool originalMicrophoneMute = false; IsMicrophoneMute(originalMicrophoneMute); @@ -3605,7 +3795,7 @@ int32_t AudioPolicyServer::GetAvailableDevices(int32_t usageIn, return ERR_INVALID_PARAM; } - descs = eventEntry_->GetAvailableDevices(usage); + descs = coreService_->GetAvailableDevices(usage); if (!hasSystemPermission) { for (auto &desc : descs) { @@ -3670,11 +3860,6 @@ int32_t AudioPolicyServer::UnsetAvailableDeviceChangeCallback(int32_t /*clientId return SUCCESS; } -int32_t AudioPolicyServer::OffloadStopPlaying(const AudioInterrupt &audioInterrupt) -{ - return audioPolicyService_.OffloadStopPlaying(std::vector(1, audioInterrupt.streamId)); -} - // LCOV_EXCL_START int32_t AudioPolicyServer::ConfigDistributedRoutingRole( const std::shared_ptr &descriptor, int32_t typeIn) @@ -4490,11 +4675,6 @@ void AudioPolicyServer::NotifyAccountsChanged(const int &id) RegisterDefaultVolumeTypeListener(); } -int32_t AudioPolicyServer::MoveToNewPipe(uint32_t sessionId, int32_t pipeType) -{ - return audioOffloadStream_.MoveToNewPipe(sessionId, static_cast(pipeType)); -} - void AudioPolicyServer::CheckHibernateState(bool hibernate) { AudioServerProxy::GetInstance().CheckHibernateStateProxy(hibernate); @@ -5148,6 +5328,12 @@ int32_t AudioPolicyServer::CallRingtoneLibrary() return SUCCESS; } +void AudioPolicyServer::SetVoiceMuteState(uint32_t sessionId, bool isMute) +{ + CHECK_AND_RETURN_LOG(coreService_ != nullptr, "coreService_ is nullptr"); + return coreService_->SetVoiceMuteState(sessionId, isMute); +} + int32_t AudioPolicyServer::SetSystemVolumeDegree(int32_t streamTypeIn, int32_t volumeDegree, int32_t volumeFlag, int32_t uid) { diff --git a/services/audio_policy/server/service/service_main/src/audio_policy_service.cpp b/services/audio_policy/server/service/service_main/src/audio_policy_service.cpp index 5c306c38bffdc9ec92e05db887ffee7fe6eeacc4..5fc0f49e59ffd5ed8946e8a88117dbbb81fc2528 100644 --- a/services/audio_policy/server/service/service_main/src/audio_policy_service.cpp +++ b/services/audio_policy/server/service/service_main/src/audio_policy_service.cpp @@ -131,6 +131,7 @@ void AudioPolicyService::CreateRecoveryThread() RecoveryDevicesThread_ = std::make_unique([this] { audioRecoveryDevice_.RecoverExcludedOutputDevices(); audioRecoveryDevice_.RecoveryPreferredDevices(); + audioBackgroundManager_.RecoryAppState(); }); pthread_setname_np(RecoveryDevicesThread_->native_handle(), "APSRecovery"); } @@ -368,7 +369,8 @@ void AudioPolicyService::UpdateA2dpOffloadFlagBySpatialService( { DeviceType spatialDevice = audioDeviceCommon_.GetSpatialDeviceType(macAddress); if (audioA2dpOffloadManager_) { - audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForAllStream(sessionIDToSpatializationEnableMap, spatialDevice); + audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForSpatializationChanged( + sessionIDToSpatializationEnableMap, spatialDevice); } } @@ -708,21 +710,6 @@ void AudioPolicyService::SetParameterCallback(const std::shared_ptr> AudioPolicyService::DeviceFi return deviceDescriptors; } -int32_t AudioPolicyService::OffloadStartPlaying(const std::vector &sessionIds) -{ -#ifdef BLUETOOTH_ENABLE - if (audioA2dpOffloadManager_) { - return audioA2dpOffloadManager_->OffloadStartPlaying(sessionIds); - } - AUDIO_WARNING_LOG("Null audioA2dpOffloadManager"); -#endif - return SUCCESS; -} - -int32_t AudioPolicyService::OffloadStopPlaying(const std::vector &sessionIds) -{ -#ifdef BLUETOOTH_ENABLE - if (audioA2dpOffloadManager_) { - return audioA2dpOffloadManager_->OffloadStopPlaying(sessionIds); - } - AUDIO_WARNING_LOG("Null audioA2dpOffloadManager"); -#endif - return SUCCESS; -} - int32_t AudioPolicyService::OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp) { Trace trace("AudioPolicyService::OffloadGetRenderPosition"); diff --git a/services/audio_policy/server/service/service_main/test/BUILD.gn b/services/audio_policy/server/service/service_main/test/BUILD.gn index f5e59bc2157ebabb5f380fc4ae780bd2845d5c79..d98ade58863b81669fb8cf471b22ef8a1632194e 100644 --- a/services/audio_policy/server/service/service_main/test/BUILD.gn +++ b/services/audio_policy/server/service/service_main/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../../../../accessibility.gni") import("../../../../../../appgallery.gni") -import("../../../../../../av_session.gni") import("../../../../../../bluetooth_part.gni") import("../../../../../../config.gni") diff --git a/services/audio_policy/server/service/service_main/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_ext_unit_test.cpp b/services/audio_policy/server/service/service_main/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_ext_unit_test.cpp index ad9829033dbbf5c0254527297a121dfa103f64da..cc1f256f99b838ff5bfbece31828ff30738ce4e6 100644 --- a/services/audio_policy/server/service/service_main/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_ext_unit_test.cpp +++ b/services/audio_policy/server/service/service_main/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_ext_unit_test.cpp @@ -312,25 +312,6 @@ HWTEST_F(AudioPolicyServiceExtUnitTest, AudioPolicyServiceTest_012, TestSize.Lev EXPECT_EQ(AUDIO_FLAG_MMAP, ret); } -/** -* @tc.name : Test AudioPolicyService. -* @tc.number: AudioPolicyServiceTest_013 -* @tc.desc : Test DynamicUnloadModule interfaces. -*/ -HWTEST_F(AudioPolicyServiceExtUnitTest, AudioPolicyServiceTest_013, TestSize.Level1) -{ - AudioPipeType pipeType; - pipeType = PIPE_TYPE_OFFLOAD; - auto ret = AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType); - EXPECT_EQ(SUCCESS, ret); - pipeType = PIPE_TYPE_MULTICHANNEL; - ret = AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType); - EXPECT_EQ(ERROR, ret); - pipeType = PIPE_TYPE_HIGHRESOLUTION; - ret = AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType); - EXPECT_EQ(SUCCESS, ret); -} - /** * @tc.name : Test AudioPolicyService. * @tc.number: AudioPolicyServiceTest_014 diff --git a/services/audio_policy/server/service/service_main/test/unittest/device_init_callback_unit_test/src/device_init_callback_unit_test.cpp b/services/audio_policy/server/service/service_main/test/unittest/device_init_callback_unit_test/src/device_init_callback_unit_test.cpp index 467339de7ebb4b75e16d086dc03963d50487e941..caf332e3fb3b64665a6b6943d7af18b47bc88e7a 100644 --- a/services/audio_policy/server/service/service_main/test/unittest/device_init_callback_unit_test/src/device_init_callback_unit_test.cpp +++ b/services/audio_policy/server/service/service_main/test/unittest/device_init_callback_unit_test/src/device_init_callback_unit_test.cpp @@ -73,6 +73,24 @@ HWTEST_F(DeviceInitCallbackUnitTest, DeviceInitCallbackUnitTest_002, TestSize.Le deviceStatusCallbackImpl->OnDeviceOnline(dmDeviceInfo); EXPECT_NE(0, dmDeviceInfo.extraData.length()); } + +/** + * @tc.name : Test OnDeviceChanged with full GetExtraDataField coverage + * @tc.number: DeviceInitCallbackUnitTest_003 + * @tc.desc : Test OnDeviceChanged triggers GetExtraDataField with all escape cases + */ +HWTEST_F(DeviceInitCallbackUnitTest, DeviceInitCallbackUnitTest_003, TestSize.Level4) +{ + auto deviceStatusCallbackImpl = make_shared(); + DistributedHardware::DmDeviceInfo dmDeviceInfo; + + strncpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, "test", 4); + strncpy_s(dmDeviceInfo.networkId, DM_MAX_DEVICE_ID_LEN, "1234", 4); + + dmDeviceInfo.extraData = "{\\\"\\\"CAR_BRAND\\\\\\\": \\\"\\\\\\\"\\\\\\\\\\\\\\\"Bugatti\\\"}"; + deviceStatusCallbackImpl->OnDeviceChanged(dmDeviceInfo); + EXPECT_NE(0, dmDeviceInfo.extraData.length()); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/server/src/test/BUILD.gn b/services/audio_policy/server/src/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ad09ff1d4016a394cb7ad9477f8ba8cc8d9517db --- /dev/null +++ b/services/audio_policy/server/src/test/BUILD.gn @@ -0,0 +1,176 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../accessibility.gni") +import("../../../../../bluetooth_part.gni") +import("../../../../../config.gni") + +group("audio_server_src_unittest_packages") { + testonly = true + deps = [ + ":audio_policy_manager_listener_unit_test", + ":audio_spatialization_state_change_listener_unit_test" + ] +} + +module_output_path = "audio_framework/audio_framework_policy/audio_policy" + +ohos_unittest("audio_policy_manager_listener_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./include", + "../../include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "distributed_notification_service:ans_innerkits", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./src/audio_policy_manager_listener_unit_test.cpp" ] + + deps = [ + "../../../../audio_policy:audio_policy_client", + "../../../../audio_policy:audio_policy_service_static", + "../../../../audio_service:audio_client", + "../../../../audio_service:audio_common", + ] +} + +ohos_unittest("audio_spatialization_state_change_listener_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./include", + "../../include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:ability_manager", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "distributed_notification_service:ans_innerkits", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "i18n:intl_util", + "image_framework:image_native", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./src/audio_spatialization_state_change_listener_unit_test.cpp" ] + + deps = [ + "../../../../audio_policy:audio_policy_client", + "../../../../audio_policy:audio_policy_service_static", + "../../../../audio_service:audio_client", + "../../../../audio_service:audio_common", + ] +} diff --git a/services/audio_policy/server/src/test/include/audio_policy_manager_listener_unit_test.h b/services/audio_policy/server/src/test/include/audio_policy_manager_listener_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..b5154ccd319e59a30347e426da031262fee3e87d --- /dev/null +++ b/services/audio_policy/server/src/test/include/audio_policy_manager_listener_unit_test.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_POLICY_MANAGER_LISTENER_UNIT_TEST_H +#define AUDIO_POLICY_MANAGER_LISTENER_UNIT_TEST_H + +#include +#include +#include "audio_policy_manager_listener.h" +#include "istandard_audio_policy_manager_listener.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioPolicyManagerListenerUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_POLICY_MANAGER_LISTENER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/src/test/include/audio_spatialization_state_change_listener_unit_test.h b/services/audio_policy/server/src/test/include/audio_spatialization_state_change_listener_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..7d17d23372973cb45dfe417e2e5508b77657836d --- /dev/null +++ b/services/audio_policy/server/src/test/include/audio_spatialization_state_change_listener_unit_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_SPATIALIZATION_STATE_CHANGE_LISTENER_UNIT_TEST_H +#define AUDIO_SPATIALIZATION_STATE_CHANGE_LISTENER_UNIT_TEST_H + +#include +#include +#include "audio_spatialization_state_change_listener.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioSpatializationStateChangeListenerUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_SPATIALIZATION_STATE_CHANGE_LISTENER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/server/src/test/src/audio_policy_manager_listener_unit_test.cpp b/services/audio_policy/server/src/test/src/audio_policy_manager_listener_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..256e922c7d8211d163ee8c0a0cd703410a4765aa --- /dev/null +++ b/services/audio_policy/server/src/test/src/audio_policy_manager_listener_unit_test.cpp @@ -0,0 +1,123 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_policy_manager_listener_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" + +#include +#include +#include + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +class MockStandardAudioPolicyManagerListener : public IStandardAudioPolicyManagerListener { +public: + sptr AsObject() override + { + return nullptr; + } + + MOCK_METHOD(ErrCode, OnInterrupt, (const InterruptEventInternal&), (override)); + + ErrCode OnRouteUpdate(uint32_t, const std::string&) override + { + return 0; + } + + ErrCode OnAvailableDeviceChange(uint32_t, const DeviceChangeAction&) override + { + return 0; + } + + ErrCode OnQueryClientType(const std::string&, uint32_t, bool& ret) override + { + ret = false; + return 0; + } + + ErrCode OnCheckClientInfo(const std::string&, int32_t&, int32_t, bool& ret) override + { + ret = false; + return 0; + } + + ErrCode OnCheckVKBInfo(const std::string&, bool& isValid) override + { + isValid = false; + return 0; + } + + ErrCode OnQueryAllowedPlayback(int32_t, int32_t, bool& ret) override + { + ret = false; + return 0; + } + + ErrCode OnBackgroundMute(int32_t) override + { + return 0; + } + + ErrCode OnQueryBundleNameIsInList(const std::string&, const std::string&, bool& ret) override + { + ret = false; + return 0; + } + + ErrCode OnQueryDeviceVolumeBehavior(VolumeBehavior&) override + { + return 0; + } +}; + +void AudioPolicyManagerListenerUnitTest::SetUpTestCase(void) {} +void AudioPolicyManagerListenerUnitTest::TearDownTestCase(void) {} +void AudioPolicyManagerListenerUnitTest::SetUp(void) {} +void AudioPolicyManagerListenerUnitTest::TearDown(void) {} + +/** + * @tc.name : Test AudioPolicyManagerListener. + * @tc.number: AudioPolicyManagerListener_001 + * @tc.desc : Test AudioPolicyManagerListener interface. + */ +HWTEST(AudioPolicyManagerListenerUnitTest, AudioPolicyManagerListener_001, TestSize.Level1) +{ + sptr nullListener = nullptr; + AudioPolicyManagerListenerCallback cb(nullListener); + InterruptEventInternal evt{}; + EXPECT_NO_THROW(cb.OnInterrupt(evt)); +} + +/** + * @tc.name : Test AudioPolicyManagerListener. + * @tc.number: AudioPolicyManagerListener_002 + * @tc.desc : Test AudioPolicyManagerListener interface. + */ +HWTEST(AudioPolicyManagerListenerUnitTest, AudioPolicyManagerListener_002, TestSize.Level1) +{ + sptr mock = new MockStandardAudioPolicyManagerListener(); + AudioPolicyManagerListenerCallback cb(mock); + InterruptEventInternal evt{}; + EXPECT_CALL(*mock, OnInterrupt(::testing::Ref(evt))).Times(1).WillOnce(Return(0)); + cb.OnInterrupt(evt); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/server/src/test/src/audio_spatialization_state_change_listener_unit_test.cpp b/services/audio_policy/server/src/test/src/audio_spatialization_state_change_listener_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0bcf1e8a7d19bc7b4fdd2209defeb52a25d2ef41 --- /dev/null +++ b/services/audio_policy/server/src/test/src/audio_spatialization_state_change_listener_unit_test.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_spatialization_state_change_listener_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" + +#include +#include +#include + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +class MockSpatializationStateChangeCallback : public AudioSpatializationStateChangeCallback { +public: + MOCK_METHOD(void, OnSpatializationStateChange, (const AudioSpatializationState&), (override)); +}; + +void AudioSpatializationStateChangeListenerUnitTest::SetUpTestCase(void) {} +void AudioSpatializationStateChangeListenerUnitTest::TearDownTestCase(void) {} +void AudioSpatializationStateChangeListenerUnitTest::SetUp(void) {} +void AudioSpatializationStateChangeListenerUnitTest::TearDown(void) {} + +/** + * @tc.name : Test AudioSpatializationStateChangeListener. + * @tc.number: AudioSpatializationStateChangeListener_001 + * @tc.desc : Test AudioSpatializationStateChangeListener OnSpatializationStateChange interface. + */ +HWTEST(AudioSpatializationStateChangeListenerUnitTest, AudioSpatializationStateChangeListener_001, TestSize.Level4) +{ + AudioSpatializationStateChangeListener listener; + AudioSpatializationState state{}; + int32_t ret = listener.OnSpatializationStateChange(state); + EXPECT_EQ(ret, AUDIO_ERR); +} + +/** + * @tc.name : Test AudioSpatializationStateChangeListener. + * @tc.number: AudioSpatializationStateChangeListener_002 + * @tc.desc : Test AudioSpatializationStateChangeListener OnSpatializationStateChange interface. + */ +HWTEST(AudioSpatializationStateChangeListenerUnitTest, AudioSpatializationStateChangeListener_002, TestSize.Level4) +{ + AudioSpatializationStateChangeListener listener; + auto mock = std::make_shared(); + listener.SetCallback(std::weak_ptr(mock)); + AudioSpatializationState state{}; + EXPECT_CALL(*mock, OnSpatializationStateChange(::testing::Ref(state))) + .Times(1) + .WillOnce([](const AudioSpatializationState&) { Return(); }); + int32_t ret = listener.OnSpatializationStateChange(state); + EXPECT_EQ(ret, AUDIO_OK); +} + +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/BUILD.gn b/services/audio_policy/test/BUILD.gn index ad033f05eaa38b4485bd823020f02ac51f0bd9ff..922f7dcc27a6c6d1cf92e8f97358ddcaa0a113ba 100644 --- a/services/audio_policy/test/BUILD.gn +++ b/services/audio_policy/test/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") @@ -25,13 +24,14 @@ group("audio_policy_unittest_packages") { testonly = true deps = [ ":audio_a2dp_device_unit_test", - ":audio_a2dp_offload_manager_unit_test", ":audio_active_device_unit_test", ":audio_adapter_manager_unit_test", ":audio_affinity_manager_unit_test", ":audio_affinity_parser_test", ":audio_background_manager_unit_test", ":audio_capturer_session_unit_test", + ":audio_client_tracker_callback_listener_unit_test", + ":audio_client_tracker_callback_service_unit_test", ":audio_collaborative_service_unit_test", ":audio_concurrency_service_unit_test", ":audio_connected_device_unit_test", @@ -54,7 +54,6 @@ group("audio_policy_unittest_packages") { ":audio_interrupt_service_pro_unit_test", ":audio_interrupt_service_unit_test", ":audio_interrupt_service_second_unit_test", - ":audio_offload_stream_unit_test", ":audio_pipe_manager_unit_test", ":audio_pipe_selector_unit_test", ":audio_pnp_server_unit_test", @@ -68,6 +67,7 @@ group("audio_policy_unittest_packages") { ":audio_policy_service_second_unit_test", ":audio_policy_service_third_unit_test", ":audio_policy_service_thirdext_unit_test", + ":audio_policy_service_extended_unit_test", ":audio_policy_state_monitor_test", ":audio_policy_utils_unit_test", ":audio_recovery_device_unit_test", @@ -98,7 +98,9 @@ group("audio_policy_unittest_packages") { ":volume_data_maintainer_unit_test", ":audio_ipc_serialization_unit_test", ":audio_device_manager_unit_test", - ":user_select_router_unit_test" + ":user_select_router_unit_test", + ":user_select_router_ext_unit_test", + "../server/domain/pipe/test/unittest:pipe_domain_unit_test_group" ] } @@ -133,6 +135,7 @@ ohos_unittest("audio_zone_service_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libprivacy_sdk", "access_token:libtokenid_sdk", @@ -230,15 +233,6 @@ ohos_unittest("audio_zone_service_unit_test") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -257,9 +251,6 @@ ohos_unittest("audio_zone_service_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_zone_unit_test") { @@ -300,6 +291,7 @@ ohos_unittest("audio_zone_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libprivacy_sdk", "access_token:libtokenid_sdk", @@ -401,15 +393,6 @@ ohos_unittest("audio_zone_unit_test") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -428,9 +411,6 @@ ohos_unittest("audio_zone_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_interrupt_service_unit_test") { @@ -472,6 +452,7 @@ ohos_unittest("audio_interrupt_service_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libprivacy_sdk", "access_token:libtokenid_sdk", @@ -561,15 +542,6 @@ ohos_unittest("audio_interrupt_service_unit_test") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -588,9 +560,6 @@ ohos_unittest("audio_interrupt_service_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_interrupt_service_second_unit_test") { @@ -632,6 +601,7 @@ ohos_unittest("audio_interrupt_service_second_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libprivacy_sdk", "access_token:libtokenid_sdk", @@ -720,15 +690,6 @@ ohos_unittest("audio_interrupt_service_second_unit_test") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -747,9 +708,6 @@ ohos_unittest("audio_interrupt_service_second_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_policy_service_first_unit_test") { @@ -786,6 +744,7 @@ ohos_unittest("audio_policy_service_first_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -912,15 +871,6 @@ ohos_unittest("audio_policy_service_first_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -939,9 +889,6 @@ ohos_unittest("audio_policy_service_first_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_policy_service_second_unit_test") { @@ -1107,15 +1054,6 @@ ohos_unittest("audio_policy_service_second_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -1134,9 +1072,6 @@ ohos_unittest("audio_policy_service_second_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_policy_service_third_unit_test") { @@ -1182,6 +1117,7 @@ ohos_unittest("audio_policy_service_third_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -1308,15 +1244,6 @@ ohos_unittest("audio_policy_service_third_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -1335,9 +1262,6 @@ ohos_unittest("audio_policy_service_third_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_microphone_descriptor_unit_test") { @@ -1375,6 +1299,7 @@ ohos_unittest("audio_microphone_descriptor_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -1501,15 +1426,6 @@ ohos_unittest("audio_microphone_descriptor_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -1528,9 +1444,6 @@ ohos_unittest("audio_microphone_descriptor_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_policy_service_thirdext_unit_test") { @@ -1570,6 +1483,7 @@ ohos_unittest("audio_policy_service_thirdext_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -1696,15 +1610,187 @@ ohos_unittest("audio_policy_service_thirdext_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { + if (audio_framework_feature_input) { + defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] + external_deps += [ "input:libmmi-client" ] + } + + if (audio_framework_feature_device_manager) { + defines += [ "FEATURE_DEVICE_MANAGER" ] + external_deps += [ "device_manager:devicemanagersdk" ] + } + + if (accessibility_enable == true) { + cflags += [ "-DACCESSIBILITY_ENABLE" ] + } + + if (bluetooth_part_enable == true) { + cflags += [ "-DBLUETOOTH_ENABLE" ] + } + +} + +ohos_unittest("audio_policy_service_extended_unit_test") { + module_out_path = module_output_path1 + include_dirs = [ + "./unittest/audio_policy_service_unit_test/include", + "../../audio_policy/server/include/service", + "../../audio_policy/server/include/service/service", + "../../audio_policy/server/domain/device/include", + "../../audio_policy/server/domain/device/src/a2dp", + "../../audio_policy/server/include", + "../../audio_policy/server/include/service/listener", + "../../audio_engine/manager/include", + "../../audio_service/server/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + public_external_deps = [ "ffrt:libffrt" ] + + public_external_deps += [ + "libxml2:libxml2", + "openssl:libcrypto_shared", + ] + + sources = [ + "./unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp", + "./unittest/audio_policy_service_unit_test/src/get_server_util.cpp", + ] + + configs = [ "../../../services/audio_policy:audio_policy_public_config" ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../../frameworks/native/hdiadapter_new:hdiadapter_new", + "../../../services/audio_engine:audio_engine_manager", + "../../../services/audio_policy:audio_policy_client", + "../../audio_policy:audio_policy_service_static", + "../../audio_service:audio_client", + ] + + if (accessibility_enable == true) { external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", ] } + defines = [] + + if (build_variant == "user") { + defines += [ "AUDIO_BUILD_VARIANT_USER" ] + } else if (build_variant == "root") { + defines += [ "AUDIO_BUILD_VARIANT_ROOT" ] + } + + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } + + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } + + if (audio_framework_feature_dtmf_tone) { + defines += [ "FEATURE_DTMF_TONE" ] + } + + if (audio_framework_feature_usb_audio) { + defines += [ "USB_ENABLE" ] + external_deps += [ "usb_manager:usbsrv_client" ] + } + + if (audio_framework_config_policy_enable) { + defines += [ "USE_CONFIG_POLICY" ] + external_deps += [ "config_policy:configpolicy_util" ] + } + + if (appgallery_part_enable == true) { + defines += [ "FEATURE_APPGALLERY" ] + } + + if (bluetooth_part_enable == true) { + deps += + [ "../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } + + if (audio_framework_feature_wired_audio) { + defines += [ "AUDIO_WIRED_DETECT" ] + } + + if (audio_framework_feature_inner_capturer) { + defines += [ "HAS_FEATURE_INNERCAPTURER" ] + } + + if (audio_framework_feature_offline_effect) { + defines += [ "FEATURE_OFFLINE_EFFECT" ] + } + + if (audio_framework_feature_distributed_audio) { + defines += [ "FEATURE_DISTRIBUTE_AUDIO" ] + } + + if (audio_framework_feature_file_io == true) { + defines += [ "FEATURE_FILE_IO" ] + } + + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } + if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -1722,10 +1808,6 @@ ohos_unittest("audio_policy_service_thirdext_unit_test") { if (bluetooth_part_enable == true) { cflags += [ "-DBLUETOOTH_ENABLE" ] } - - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_effect_config_parser_test") { @@ -1900,148 +1982,6 @@ ohos_unittest("audio_socket_thread_unit_test") { deps = [ "../../audio_policy:audio_policy_service_static" ] } -ohos_unittest("audio_offload_stream_unit_test") { - module_out_path = module_output_path1 - include_dirs = [ - "./unittest/audio_offload_stream_unit_test/include", - "../../audio_policy/server/src/service/service", - "../../audio_policy/server/include/service/service", - "../../audio_policy/server/domain/device/include", - "../../audio_policy/server/domain/device/src/a2dp", - ] - - use_exceptions = true - - cflags = [ - "-Wall", - "-Werror", - "-Wno-macro-redefined", - ] - - cflags_cc = cflags - cflags_cc += [ "-fno-access-control" ] - - sanitize = { - cfi = true - cfi_cross_dso = true - boundary_sanitize = true - debug = false - integer_overflow = true - ubsan = true - } - - external_deps = [ - "ability_base:want", - "access_token:libaccesstoken_sdk", - "access_token:libprivacy_sdk", - "access_token:libtokenid_sdk", - "access_token:libtokensetproc_shared", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "data_share:datashare_common", - "data_share:datashare_consumer", - "hdf_core:libhdf_ipc_adapter", - "hdf_core:libhdi", - "hdf_core:libpub_utils", - "hilog:libhilog", - "ipc:ipc_single", - "kv_store:distributeddata_inner", - "os_account:os_account_innerkits", - "power_manager:powermgr_client", - "safwk:system_ability_fwk", - ] - - sources = [ "./unittest/audio_offload_stream_unit_test/src/audio_offload_stream_unit_test.cpp" ] - - deps = [ - "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", - "../../audio_policy:audio_policy_service_static", - ] - - defines = [] - if (audio_framework_feature_wired_audio) { - defines += [ "AUDIO_WIRED_DETECT" ] - #sources += [ - # "server/domain/device/src/pnp/audio_input_thread.cpp", - # "server/domain/device/src/pnp/audio_pnp_server.cpp", - # "server/domain/device/src/pnp/audio_socket_thread.cpp", - #] - } - - if (build_variant == "user") { - defines += [ "AUDIO_BUILD_VARIANT_USER" ] - } else if (build_variant == "root") { - defines += [ "AUDIO_BUILD_VARIANT_ROOT" ] - } - - if (use_libfuzzer || use_clang_coverage) { - defines += [ "TEST_COVERAGE" ] - } - - if (audio_framework_feature_support_os_account) { - defines += [ "SUPPORT_USER_ACCOUNT" ] - } - - if (audio_framework_feature_dtmf_tone) { - #sources += [ "server/infra/config/parser/src/audio_tone_parser.cpp" ] - defines += [ "FEATURE_DTMF_TONE" ] - } - - if (is_emulator) { - defines += [ "IS_EMULATOR" ] - } - - if (audio_framework_feature_inner_capturer) { - defines += [ "HAS_FEATURE_INNERCAPTURER" ] - } - - configs = [ "../../../services/audio_policy:audio_policy_public_config" ] - - public_external_deps = [ "ffrt:libffrt" ] - - public_external_deps += [ - "libxml2:libxml2", - "openssl:libcrypto_shared", - ] - - if (audio_framework_feature_usb_audio) { - defines += [ "USB_ENABLE" ] - external_deps += [ "usb_manager:usbsrv_client" ] - - #sources += [ "server/domain/device/src/pnp/audio_usb_manager.cpp" ] - } - - if (audio_framework_feature_detect_soundbox) { - defines += [ "DETECT_SOUNDBOX" ] - } - - if (audio_framework_config_policy_enable) { - defines += [ "USE_CONFIG_POLICY" ] - external_deps += [ "config_policy:configpolicy_util" ] - } - - if (appgallery_part_enable == true) { - defines += [ "FEATURE_APPGALLERY" ] - } - - if (bluetooth_part_enable == true) { - deps += - [ "../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] - external_deps += [ "bluetooth:btframework" ] - } - - if (audio_framework_feature_input) { - defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] - external_deps += [ "input:libmmi-client" ] - } - - if (audio_framework_feature_device_manager) { - defines += [ "FEATURE_DEVICE_MANAGER" ] - external_deps += [ "device_manager:devicemanagersdk" ] - } -} - ohos_unittest("audio_policy_server_unit_test") { module_out_path = module_output_path1 include_dirs = [ @@ -2587,6 +2527,7 @@ ohos_unittest("audio_router_center_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libprivacy_sdk", "access_token:libtokenid_sdk", @@ -2671,14 +2612,6 @@ ohos_unittest("audio_router_center_unit_test") { external_deps += [ "device_manager:devicemanagersdk" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } } ohos_unittest("privacy_priority_router_unit_test") { @@ -2983,11 +2916,12 @@ ohos_unittest("audio_stream_collector_unit_test") { sanitize = { cfi = true - cfi_cross_dso = true + cfi_cross_dso = false boundary_sanitize = true debug = false integer_overflow = true - ubsan = true + ubsan = false + blocklist = "${audio_framework_root}/cfi_blocklist.txt" } external_deps = [ @@ -3403,6 +3337,7 @@ ohos_unittest("audio_interrupt_service_pro_unit_test") { "ability_runtime:app_manager", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libprivacy_sdk", "access_token:libtokenid_sdk", @@ -3498,15 +3433,6 @@ ohos_unittest("audio_interrupt_service_pro_unit_test") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -3525,9 +3451,6 @@ ohos_unittest("audio_interrupt_service_pro_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("volume_data_maintainer_unit_test") { @@ -3974,46 +3897,11 @@ ohos_unittest("audio_general_manager_unit_test") { "./unittest/audio_general_manager_unit_test/include", "../../../services/audio_policy/util/include", "../../../services/audio_policy/client/service/include", - "../../../interfaces/inner_api/native/audiocommon/include", - "../../../services/audio_policy/server/domain/effect/include", - "../../../services/audio_policy/server/infra/config/parser/include", - "../../../interfaces/inner_api/native/audiomanager/include", - "../../../services/audio_service/client/include", - ] - - use_exceptions = true - - cflags = [ - "-Wall", - "-Werror", - "-Wno-macro-redefined", - "-fno-access-control", - ] - - external_deps = [ - "bounds_checking_function:libsec_shared", - "c_utils:utils", - "eventhandler:libeventhandler", - "hilog:libhilog", - "init:libbegetutil", - "ipc:ipc_single", - "samgr:samgr_proxy", - ] - - sources = [ "./unittest/audio_general_manager_unit_test/src/audio_general_manager_unit_test.cpp" ] - - deps = [ - "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", - "../../../services/audio_policy:audio_foundation", - "../../../services/audio_policy:audio_manager_client", - ] -} - -ohos_unittest("audio_active_device_unit_test") { - module_out_path = module_output_path - include_dirs = [ - "../server/include", - "./unittest/audio_active_device_unit_test/include", + "../../../interfaces/inner_api/native/audiocommon/include", + "../../../services/audio_policy/server/domain/effect/include", + "../../../services/audio_policy/server/infra/config/parser/include", + "../../../interfaces/inner_api/native/audiomanager/include", + "../../../services/audio_service/client/include", ] use_exceptions = true @@ -4026,59 +3914,29 @@ ohos_unittest("audio_active_device_unit_test") { ] external_deps = [ - "ability_base:session_info", - "ability_base:want", - "ability_base:zuri", - "ability_runtime:ability_connect_callback_stub", - "ability_runtime:ability_context_native", - "ability_runtime:app_context", - "ability_runtime:dataobs_manager", - "ability_runtime:extension_manager", - "access_token:libaccesstoken_sdk", - "access_token:libprivacy_sdk", - "access_token:libtokenid_sdk", - "access_token:libtokensetproc_shared", - "bluetooth:btframework", "bounds_checking_function:libsec_shared", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", "c_utils:utils", - "data_share:datashare_common", - "data_share:datashare_consumer", - "drivers_interface_audio:libaudio_proxy_5.0", "eventhandler:libeventhandler", - "googletest:gmock", - "hdf_core:libhdf_host", - "hdf_core:libhdf_ipc_adapter", - "hdf_core:libhdf_utils", - "hdf_core:libhdi", - "hdf_core:libpub_utils", "hilog:libhilog", - "hisysevent:libhisysevent", "init:libbegetutil", "ipc:ipc_single", - "media_foundation:media_monitor_client", - "media_foundation:media_monitor_common", - "os_account:os_account_innerkits", - "power_manager:power_setting", - "power_manager:powermgr_client", - "safwk:system_ability_fwk", "samgr:samgr_proxy", ] - sources = [ "./unittest/audio_active_device_unit_test/src/audio_active_device_unit_test.cpp" ] + sources = [ "./unittest/audio_general_manager_unit_test/src/audio_general_manager_unit_test.cpp" ] deps = [ "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", - "../../audio_policy:audio_policy_service_static", + "../../../services/audio_policy:audio_foundation", + "../../../services/audio_policy:audio_manager_client", ] } -ohos_unittest("audio_a2dp_offload_manager_unit_test") { +ohos_unittest("audio_active_device_unit_test") { module_out_path = module_output_path include_dirs = [ "../server/include", - "./unittest/audio_a2dp_offload_manager_unit_test/include", + "./unittest/audio_active_device_unit_test/include", ] use_exceptions = true @@ -4090,8 +3948,6 @@ ohos_unittest("audio_a2dp_offload_manager_unit_test") { "-fno-access-control", ] - defines = [ "BLUETOOTH_ENABLE" ] - external_deps = [ "ability_base:session_info", "ability_base:want", @@ -4133,7 +3989,7 @@ ohos_unittest("audio_a2dp_offload_manager_unit_test") { "samgr:samgr_proxy", ] - sources = [ "./unittest/audio_a2dp_offload_manager_unit_test/src/audio_a2dp_offload_manager_unit_test.cpp" ] + sources = [ "./unittest/audio_active_device_unit_test/src/audio_active_device_unit_test.cpp" ] deps = [ "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", @@ -5059,6 +4915,7 @@ ohos_unittest("audio_background_manager_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -5120,14 +4977,6 @@ ohos_unittest("audio_background_manager_unit_test") { defines = [] - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } } ohos_unittest("audio_setting_provider_unit_test") { @@ -5200,11 +5049,12 @@ ohos_unittest("audio_strategy_router_parser_unit_test") { sanitize = { cfi = true - cfi_cross_dso = true + cfi_cross_dso = false boundary_sanitize = true debug = false integer_overflow = true - ubsan = true + ubsan = false + blocklist = "${audio_framework_root}/cfi_blocklist.txt" } configs = [ "${audio_framework_root}/services/audio_service/idl:audio_service_sa_idl_config" ] @@ -5352,6 +5202,109 @@ ohos_unittest("audio_capturer_session_unit_test") { ] } +ohos_unittest("audio_client_tracker_callback_listener_unit_test") { + module_out_path = module_output_path + + include_dirs = [ "./unittest/audio_client_tracker_callback_listener_unit_test/include" ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + external_deps = [ + "bluetooth:btframework", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "googletest:gmock", + "hilog:libhilog", + "init:libbegetutil", + "kv_store:distributeddata_inner", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + "eventhandler:libeventhandler", + ] + + sources = [ "./unittest/audio_client_tracker_callback_listener_unit_test/src/audio_client_tracker_callback_listener_unit_test.cpp" ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../audio_policy:audio_policy_service_static", + ] +} + +ohos_unittest("audio_client_tracker_callback_service_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "../server/include", + "./unittest/audio_client_tracker_callback_service_unit_test/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bluetooth:btframework", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./unittest/audio_client_tracker_callback_service_unit_test/src/audio_client_tracker_callback_service_unit_test.cpp" ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../audio_policy:audio_policy_service_static", + ] +} + ohos_unittest("audio_core_service_entry_unit_test") { module_out_path = module_output_path @@ -5501,6 +5454,7 @@ ohos_unittest("audio_core_service_unit_test") { "ability_runtime:app_context", "ability_runtime:dataobs_manager", "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", "access_token:libaccesstoken_sdk", "access_token:libnativetoken_shared", "access_token:libprivacy_sdk", @@ -5627,15 +5581,6 @@ ohos_unittest("audio_core_service_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -5654,9 +5599,6 @@ ohos_unittest("audio_core_service_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_core_service_utils_unit_test") { @@ -5804,15 +5746,6 @@ ohos_unittest("audio_core_service_utils_unit_test") { defines += [ "SUPPORT_LOW_LATENCY" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -5831,9 +5764,6 @@ ohos_unittest("audio_core_service_utils_unit_test") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } ohos_unittest("audio_pipe_manager_unit_test") { @@ -6291,4 +6221,102 @@ ohos_unittest("user_select_router_unit_test") { defines += [ "USB_ENABLE" ] external_deps += [ "usb_manager:usbsrv_client" ] } +} + +ohos_unittest("user_select_router_ext_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./unittest/user_select_router_unit_test/include", + "../../audio_policy/server/domain/router", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:want", + "ability_runtime:app_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "background_task_mgr:bgtaskmgr_innerkits", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + "pulseaudio:pulse", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp" ] + + deps = [ + "../../../frameworks/native/bluetoothclient:audio_bluetooth_client", + "../../audio_policy:audio_policy_client", + "../../audio_policy:audio_policy_service_static", + "../../audio_service:audio_client", + "../../audio_service:audio_common", + ] + + if (accessibility_enable == true) { + external_deps += [ + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", + ] + } + + defines = [] + if (audio_framework_feature_dtmf_tone) { + defines += [ "FEATURE_DTMF_TONE" ] + } + + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } + + if (build_variant == "user") { + defines += [ "AUDIO_BUILD_VARIANT_USER" ] + } else if (build_variant == "root") { + defines += [ "AUDIO_BUILD_VARIANT_ROOT" ] + } + + if (appgallery_part_enable == true) { + defines += [ "FEATURE_APPGALLERY" ] + } + + if (bluetooth_part_enable == true) { + external_deps += [ "bluetooth:btframework" ] + } + + if (audio_framework_feature_input) { + defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] + external_deps += [ "input:libmmi-client" ] + } + + if (audio_framework_feature_device_manager) { + defines += [ "FEATURE_DEVICE_MANAGER" ] + external_deps += [ "device_manager:devicemanagersdk" ] + } } \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_a2dp_offload_manager_unit_test/src/audio_a2dp_offload_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_a2dp_offload_manager_unit_test/src/audio_a2dp_offload_manager_unit_test.cpp deleted file mode 100644 index fd0f4abbfb2cb36398c9f2d7bf0938f445ee345c..0000000000000000000000000000000000000000 --- a/services/audio_policy/test/unittest/audio_a2dp_offload_manager_unit_test/src/audio_a2dp_offload_manager_unit_test.cpp +++ /dev/null @@ -1,903 +0,0 @@ -/* - * Copyright (c) 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 - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "audio_policy_utils.h" -#include "audio_a2dp_offload_manager_unit_test.h" - -using namespace testing::ext; - -namespace OHOS { -namespace AudioStandard { - -void AudioA2dpOffloadManagerUnitTest::SetUpTestCase(void) {} -void AudioA2dpOffloadManagerUnitTest::TearDownTestCase(void) {} -void AudioA2dpOffloadManagerUnitTest::SetUp(void) {} -void AudioA2dpOffloadManagerUnitTest::TearDown(void) {} - -/** - * @tc.name: ConnectA2dpOffload_001 - * @tc.desc: Test ConnectA2dpOffload with state already connected. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, ConnectA2dpOffload_001, TestSize.Level1) -{ - std::string deviceAddress = "00:11:22:33:44:55"; - std::vector sessionIds = {1, 2, 3}; - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - manager->ConnectA2dpOffload(deviceAddress, sessionIds); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTED); -} - -/** - * @tc.name: ConnectA2dpOffload_002 - * @tc.desc: Test ConnectA2dpOffload with state already connecting. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, ConnectA2dpOffload_002, TestSize.Level1) -{ - std::string deviceAddress = "00:11:22:33:44:55"; - std::vector sessionIds = {1, 2, 3}; - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); - manager->ConnectA2dpOffload(deviceAddress, sessionIds); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTING); -} - -/** - * @tc.name: ConnectA2dpOffload_003 - * @tc.desc: Test ConnectA2dpOffload with state disconnected. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, ConnectA2dpOffload_003, TestSize.Level1) -{ - std::string deviceAddress = "00:11:22:33:44:55"; - std::vector sessionIds = {1, 2, 3}; - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_DISCONNECTED); - manager->ConnectA2dpOffload(deviceAddress, sessionIds); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTING); -} - -/** - * @tc.name: WaitForConnectionCompleted_001 - * @tc.desc: Test WaitForConnectionCompleted with connection timeout. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, WaitForConnectionCompleted_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const int32_t shortTimeout = 100; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_DISCONNECTED); - std::thread testThread([manager]() { - manager->WaitForConnectionCompleted(); - }); - std::this_thread::sleep_for(std::chrono::milliseconds(shortTimeout + 100)); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_DISCONNECTED); - testThread.join(); -} - - -/** - * @tc.name: OffloadStartPlaying_001 - * @tc.desc: Test OffloadStartPlaying with entering the second if branch. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - std::vector sessionIds = {1, 2, 3}; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_DISCONNECTED); - int32_t ret = manager->OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_DISCONNECTED); -} - -/** - * @tc.name: OffloadStartPlaying_002 - * @tc.desc: Test OffloadStartPlaying without entering the second if branch due to ret != SUCCESS. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - std::vector sessionIds = {1, 2, 3}; - int32_t ret = manager->OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_DISCONNECTED); -} - -/** - * @tc.name: OffloadStartPlaying_003 - * @tc.desc: Test OffloadStartPlaying without entering the second if branch due to state == CONNECTION_STATUS_CONNECTED. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - std::vector sessionIds = {1, 2, 3}; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - int32_t ret = manager->OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetCurrentOffloadConnectedState(), CONNECTION_STATUS_CONNECTED); -} - -/** - * @tc.name: OffloadStartPlaying_004 - * @tc.desc: Test OffloadStartPlaying - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_004, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_NOT_OFFLOAD); - std::vector sessionIds = {1, 2, 3}; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - int32_t ret = manager->OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, SUCCESS); -} - -/** - * @tc.name: OffloadStartPlaying_005 - * @tc.desc: Test OffloadStartPlaying - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStartPlaying_005, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - std::vector sessionIds = {}; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - int32_t ret = manager->OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, SUCCESS); -} - -/** - * @tc.name: OffloadStopPlaying_001 - * @tc.desc: Test OffloadStopPlaying without entering the if branch. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OffloadStopPlaying_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - std::vector sessionIds = {1, 2, 3}; - int32_t ret = manager->OffloadStopPlaying(sessionIds); - EXPECT_EQ(ret, BASE_AUDIO_ERR_OFFSET); -} - -/** - * @tc.name: UpdateA2dpOffloadFlagForAllStream_001 - * @tc.desc: Test UpdateA2dpOffloadFlagForAllStream with entering all if branches. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForAllStream_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::unordered_map sessionIDToSpatializationEnableMap = { - {1, true}, - {2, false} - }; - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector> audioRendererChangeInfos; - auto changeInfo1 = std::make_shared(); - changeInfo1->sessionId = 1; - changeInfo1->rendererState = RENDERER_RUNNING; - audioRendererChangeInfos.push_back(changeInfo1); - - auto changeInfo2 = std::make_shared(); - changeInfo2->sessionId = 2; - changeInfo2->rendererState = RENDERER_STOPPED; - audioRendererChangeInfos.push_back(changeInfo2); - manager->streamCollector_.audioRendererChangeInfos_ = audioRendererChangeInfos; - manager->UpdateA2dpOffloadFlagForAllStream(sessionIDToSpatializationEnableMap, deviceType); - EXPECT_EQ(manager->streamCollector_.audioRendererChangeInfos_, audioRendererChangeInfos); -} - - -/** - * @tc.name: UpdateA2dpOffloadFlagForAllStream_002 - * @tc.desc: Test UpdateA2dpOffloadFlagForAllStream without entering any if branches. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlagForAllStream_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::unordered_map sessionIDToSpatializationEnableMap; - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector> audioRendererChangeInfos; - auto changeInfo1 = std::make_shared(); - changeInfo1->sessionId = 1; - changeInfo1->rendererState = RENDERER_RUNNING; - audioRendererChangeInfos.push_back(changeInfo1); - - auto changeInfo2 = std::make_shared(); - changeInfo2->sessionId = 2; - changeInfo2->rendererState = RENDERER_RUNNING; - audioRendererChangeInfos.push_back(changeInfo2); - manager->streamCollector_.audioRendererChangeInfos_ = audioRendererChangeInfos; - manager->UpdateA2dpOffloadFlagForAllStream(sessionIDToSpatializationEnableMap, deviceType); - EXPECT_EQ(manager->streamCollector_.audioRendererChangeInfos_, audioRendererChangeInfos); -} - -/** - * @tc.name: UpdateA2dpOffloadFlag_001 - * @tc.desc: Test UpdateA2dpOffloadFlag with deviceType DEVICE_TYPE_BLUETOOTH_A2DP - * and receiveOffloadFlag != GetA2dpOffloadFlag. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlag_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector allActiveSessions; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - a2dpStreamInfo.sessionId = 1; - a2dpStreamInfo.streamType = 1; - a2dpStreamInfo.isSpatialAudio = false; - allActiveSessions.push_back(a2dpStreamInfo); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - manager->UpdateA2dpOffloadFlag(allActiveSessions, deviceType); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: UpdateA2dpOffloadFlag_002 - * @tc.desc: Test UpdateA2dpOffloadFlag with deviceType DEVICE_TYPE_NONE and current output device is BLUETOOTH_A2DP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlag_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - DeviceType deviceType = DEVICE_TYPE_NONE; - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - std::vector allActiveSessions; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - a2dpStreamInfo.sessionId = 1; - a2dpStreamInfo.streamType = 1; - a2dpStreamInfo.isSpatialAudio = false; - allActiveSessions.push_back(a2dpStreamInfo); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - manager->UpdateA2dpOffloadFlag(allActiveSessions, deviceType); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: UpdateA2dpOffloadFlag_003 - * @tc.desc: Test UpdateA2dpOffloadFlag with receiveOffloadFlag == NO_A2DP_DEVICE. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlag_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector allActiveSessions; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - a2dpStreamInfo.sessionId = 1; - a2dpStreamInfo.streamType = 1; - a2dpStreamInfo.isSpatialAudio = false; - allActiveSessions.push_back(a2dpStreamInfo); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - manager->UpdateA2dpOffloadFlag(allActiveSessions, deviceType); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: UpdateA2dpOffloadFlag_004 - * @tc.desc: Test UpdateA2dpOffloadFlag with receiveOffloadFlag == GetA2dpOffloadFlag and both are A2DP_OFFLOAD. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, UpdateA2dpOffloadFlag_004, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector allActiveSessions; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - a2dpStreamInfo.sessionId = 1; - a2dpStreamInfo.streamType = 1; - a2dpStreamInfo.isSpatialAudio = false; - allActiveSessions.push_back(a2dpStreamInfo); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - manager->UpdateA2dpOffloadFlag(allActiveSessions, deviceType); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: HandleA2dpDeviceOutOffload_001 - * @tc.desc: Test HandleA2dpDeviceOutOffload with current output device type being BLUETOOTH_A2DP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleA2dpDeviceOutOffload_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor descriptor; - descriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - manager->audioActiveDevice_.SetCurrentOutputDevice(descriptor); - BluetoothOffloadState a2dpOffloadFlag = NO_A2DP_DEVICE; - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - int32_t result = manager->HandleA2dpDeviceOutOffload(a2dpOffloadFlag); - EXPECT_EQ(result, manager->HandleActiveDevice(deviceDescriptor)); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetA2dpOffloadFlag(), a2dpOffloadFlag); -} - -/** - * @tc.name: HandleA2dpDeviceOutOffload_002 - * @tc.desc: Test HandleA2dpDeviceOutOffload with current output device type not being BLUETOOTH_A2DP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleA2dpDeviceOutOffload_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP_IN; - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - BluetoothOffloadState a2dpOffloadFlag = NO_A2DP_DEVICE; - int32_t result = manager->HandleA2dpDeviceOutOffload(a2dpOffloadFlag); - EXPECT_EQ(result, SUCCESS); - EXPECT_EQ(manager->audioA2dpOffloadFlag_.GetA2dpOffloadFlag(), a2dpOffloadFlag); -} - -/** - * @tc.name: HandleA2dpDeviceInOffload_001 - * @tc.desc: Test HandleA2dpDeviceInOffload with A2DP offload connected. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleA2dpDeviceInOffload_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_OFFLOAD); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - int32_t result = manager->HandleA2dpDeviceInOffload(A2DP_OFFLOAD); - EXPECT_EQ(result, SUCCESS); -} - -/** - * @tc.name: HandleA2dpDeviceInOffload_002 - * @tc.desc: Test HandleA2dpDeviceInOffload when the if condition is not met. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleA2dpDeviceInOffload_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->SetA2dpOffloadFlag(A2DP_NOT_OFFLOAD); - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); - int32_t result = manager->HandleA2dpDeviceInOffload(A2DP_NOT_OFFLOAD); - EXPECT_EQ(result, SUCCESS); -} -/** - * @tc.name: GetA2dpOffloadCodecAndSendToDsp_001 - * @tc.desc: Test GetA2dpOffloadCodecAndSendToDsp without entering the if branch. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetA2dpOffloadCodecAndSendToDsp_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER; - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - manager->GetA2dpOffloadCodecAndSendToDsp(); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: GetA2dpOffloadCodecAndSendToDsp_002 - * @tc.desc: Test GetA2dpOffloadCodecAndSendToDsp when entering the if branch. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetA2dpOffloadCodecAndSendToDsp_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER; - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - manager->GetA2dpOffloadCodecAndSendToDsp(); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: FetchStreamForA2dpOffload_001 - * @tc.desc: Test FetchStreamForA2dpOffload when IsRendererStreamRunning returns false. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, FetchStreamForA2dpOffload_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC; - changeInfo->clientUID = 123; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - manager->FetchStreamForA2dpOffload(false); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: FetchStreamForA2dpOffload_002 - * @tc.desc: Test FetchStreamForA2dpOffload when deviceType is not BLUETOOTH_A2DP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, FetchStreamForA2dpOffload_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC; - changeInfo->clientUID = 123; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - manager->FetchStreamForA2dpOffload(false); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: FetchStreamForA2dpOffload_003 - * @tc.desc: Test FetchStreamForA2dpOffload when requireReset is false and rendererFlags is not AUDIO_FLAG_MMAP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, FetchStreamForA2dpOffload_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC; - changeInfo->clientUID = 123; - changeInfo->rendererInfo.rendererFlags = STREAM_USAGE_UNKNOWN; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - manager->FetchStreamForA2dpOffload(false); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: FetchStreamForA2dpOffload_004 - * @tc.desc: Test FetchStreamForA2dpOffload when requireReset is true and rendererFlags is not AUDIO_FLAG_MMAP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, FetchStreamForA2dpOffload_004, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - - // 创建 rendererChangeInfos - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC; - changeInfo->clientUID = 123; - changeInfo->rendererInfo.rendererFlags = STREAM_USAGE_UNKNOWN; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - manager->FetchStreamForA2dpOffload(true); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: FetchStreamForA2dpOffload_005 - * @tc.desc: Test FetchStreamForA2dpOffload when requireReset is true and rendererFlags is AUDIO_FLAG_MMAP. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, FetchStreamForA2dpOffload_005, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC; - changeInfo->clientUID = 123; - changeInfo->rendererInfo.rendererFlags = AUDIO_FLAG_MMAP; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - manager->FetchStreamForA2dpOffload(true); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: GetAllRunningStreamSession_001 - * @tc.desc: Test GetAllRunningStreamSession when rendererState is not RUNNING and doStop is true. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetAllRunningStreamSession_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererState = RENDERER_PAUSED; - changeInfo->sessionId = 123; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - std::vector allSessions; - manager->GetAllRunningStreamSession(allSessions, true); - EXPECT_TRUE(allSessions.empty()); -} - -/** - * @tc.name: GetAllRunningStreamSession_002 - * @tc.desc: Test GetAllRunningStreamSession when rendererState is not RUNNING and doStop is false. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetAllRunningStreamSession_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererState = RENDERER_PAUSED; // 不是 RUNNING - changeInfo->sessionId = 123; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - std::vector allSessions; - manager->GetAllRunningStreamSession(allSessions, false); - EXPECT_TRUE(allSessions.empty()); -} - -/** - * @tc.name: GetAllRunningStreamSession_003 - * @tc.desc: Test GetAllRunningStreamSession when rendererState is RUNNING and doStop is true. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetAllRunningStreamSession_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererState = RENDERER_RUNNING; - changeInfo->sessionId = 123; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - std::vector allSessions; - manager->GetAllRunningStreamSession(allSessions, true); - EXPECT_EQ(allSessions.size(), 1); - EXPECT_EQ(allSessions[0], 123); -} - -/** - * @tc.name: GetAllRunningStreamSession_004 - * @tc.desc: Test GetAllRunningStreamSession when rendererState is RUNNING and doStop is false. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetAllRunningStreamSession_004, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - changeInfo->rendererState = RENDERER_RUNNING; - changeInfo->sessionId = 123; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - std::vector allSessions; - manager->GetAllRunningStreamSession(allSessions, false); - EXPECT_EQ(allSessions.size(), 1); - EXPECT_EQ(allSessions[0], 123); -} - -/** - * @tc.name: GetVolumeGroupType_001 - * @tc.desc: Test GetVolumeGroupType when deviceType is DEVICE_TYPE_HDMI. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetVolumeGroupType_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::string volumeGroupType = manager->GetVolumeGroupType(DEVICE_TYPE_HDMI); - EXPECT_EQ(volumeGroupType, "build-in"); -} - -/** - * @tc.name: GetVolumeGroupType_002 - * @tc.desc: Test GetVolumeGroupType when deviceType is DEVICE_TYPE_BLUETOOTH_SCO. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetVolumeGroupType_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::string volumeGroupType = manager->GetVolumeGroupType(DEVICE_TYPE_BLUETOOTH_SCO); - EXPECT_EQ(volumeGroupType, "wireless"); -} - -/** - * @tc.name: GetVolumeGroupType_003 - * @tc.desc: Test GetVolumeGroupType when deviceType is DEVICE_TYPE_USB_ARM_HEADSET. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetVolumeGroupType_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::string volumeGroupType = manager->GetVolumeGroupType(DEVICE_TYPE_USB_ARM_HEADSET); - EXPECT_EQ(volumeGroupType, "wired"); -} - -/** - * @tc.name: GetVolumeGroupType_004 - * @tc.desc: Test GetVolumeGroupType when deviceType is not supported. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, GetVolumeGroupType_004, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::string volumeGroupType = manager->GetVolumeGroupType(DEVICE_TYPE_MAX); - EXPECT_EQ(volumeGroupType, ""); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_001 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = "123"; - int32_t playingState = 1; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_002 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = "123"; - int32_t playingState = 2; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_003 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = "123"; - int32_t playingState = 1; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_004 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_004, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = manager->a2dpOffloadDeviceAddress_; - int32_t playingState = 2; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_005 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_005, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = manager->a2dpOffloadDeviceAddress_; - int32_t playingState = 2; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_006 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_006, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = manager->a2dpOffloadDeviceAddress_; - int32_t playingState = 1; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: OnA2dpPlayingStateChanged_007 - * @tc.desc: Test OnA2dpPlayingStateChanged. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, OnA2dpPlayingStateChanged_007, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - const std::string deviceAddress = manager->a2dpOffloadDeviceAddress_; - int32_t playingState = 3; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTED); - manager->OnA2dpPlayingStateChanged(deviceAddress, playingState); - EXPECT_NE(manager, nullptr); -} - -/** - * @tc.name: IsA2dpOffloadConnecting_001 - * @tc.desc: Test IsA2dpOffloadConnecting when entering the if branch. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, IsA2dpOffloadConnecting_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - manager->connectionTriggerSessionIds_ = {123}; - manager->audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(CONNECTION_STATUS_CONNECTING); - bool result = manager->IsA2dpOffloadConnecting(123); - EXPECT_TRUE(result); -} - -/** - * @tc.name: HandleActiveDevice_001 - * @tc.desc: Test HandleActiveDevice. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleActiveDevice_001, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_NONE; - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - manager->audioConfigManager_.isUpdateRouteSupported_ = true; - int32_t result = manager->HandleActiveDevice(deviceDescriptor); - EXPECT_EQ(result, ERR_OPERATION_FAILED); -} - -/** - * @tc.name: HandleActiveDevice_002 - * @tc.desc: Test HandleActiveDevice. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleActiveDevice_002, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - AudioDeviceDescriptor preDeviceDescriptor; - preDeviceDescriptor.deviceType_ = DEVICE_TYPE_EARPIECE; - manager->audioActiveDevice_.SetCurrentOutputDevice(preDeviceDescriptor); - manager->audioConfigManager_.isUpdateRouteSupported_ = false; - int32_t result = manager->HandleActiveDevice(deviceDescriptor); - EXPECT_EQ(result, SUCCESS); -} - -/** - * @tc.name: HandleActiveDevice_003 - * @tc.desc: Test HandleActiveDevice. - * @tc.type: FUNC - * @tc.require: #I5Y4MZ - */ -HWTEST_F(AudioA2dpOffloadManagerUnitTest, HandleActiveDevice_003, TestSize.Level1) -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = DEVICE_TYPE_MIC; - AudioDeviceDescriptor preDeviceDescriptor; - preDeviceDescriptor.deviceType_ = DEVICE_TYPE_EARPIECE; - manager->audioActiveDevice_.SetCurrentOutputDevice(preDeviceDescriptor); - manager->audioConfigManager_.isUpdateRouteSupported_ = false; - int32_t result = manager->HandleActiveDevice(deviceDescriptor); - EXPECT_EQ(result, SUCCESS); -} - -} // namespace AudioStandard -} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_active_device_unit_test/src/audio_active_device_unit_test.cpp b/services/audio_policy/test/unittest/audio_active_device_unit_test/src/audio_active_device_unit_test.cpp index 6d8e882072f429bafb02cc684c9a798e9efbe05c..9ed0057805ad33cfa1575ef6c9fdb76888659289 100644 --- a/services/audio_policy/test/unittest/audio_active_device_unit_test/src/audio_active_device_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_active_device_unit_test/src/audio_active_device_unit_test.cpp @@ -211,26 +211,6 @@ HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_009, TestSize.Leve EXPECT_NE(audioActiveDevice, nullptr); } -/** -* @tc.name : Test AudioActiveDevice. -* @tc.number: AudioActiveDeviceUnitTest_010. -* @tc.desc : Test CheckActiveOutputDeviceSupportOffload. -*/ -HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_010, TestSize.Level1) -{ - auto audioActiveDevice = std::make_shared(); - - AudioDeviceDescriptor audioDeviceDescriptor1(DeviceType::DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); - audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor1); - bool result = audioActiveDevice->CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(result, true); - - AudioDeviceDescriptor audioDeviceDescriptor(DeviceType::DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); - audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor); - auto ret = audioActiveDevice->CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(ret, false); -} - /** * @tc.name : Test AudioActiveDevice. * @tc.number: AudioActiveDeviceUnitTest_011. @@ -266,5 +246,48 @@ HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_012, TestSize.Leve result = audioActiveDevice->IsDeviceActive(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO); EXPECT_EQ(result, false); } + +/** +* @tc.name : Test AudioActiveDevice. +* @tc.number: GetCurrentInputDeviceMacAddr_001. +* @tc.desc : Test GetCurrentInputDeviceMacAddr. +*/ +HWTEST_F(AudioActiveDeviceUnitTest, GetCurrentInputDeviceMacAddr_001, TestSize.Level1) +{ + auto audioActiveDevice = std::make_shared(); + + audioActiveDevice->currentActiveDevice_.macAddress_ = "00:11:22:33:44:55"; + string ret = audioActiveDevice->GetCurrentInputDeviceMacAddr(); + EXPECT_EQ(ret, "00:11:22:33:44:55"); +} + +/** +* @tc.name : Test AudioActiveDevice. +* @tc.number: GetCurrentOutputDeviceCategory_001. +* @tc.desc : Test GetCurrentOutputDeviceCategory. +*/ +HWTEST_F(AudioActiveDeviceUnitTest, GetCurrentOutputDeviceCategory_001, TestSize.Level1) +{ + auto audioActiveDevice = std::make_shared(); + + DeviceCategory ret = audioActiveDevice->GetCurrentOutputDeviceCategory(); + EXPECT_EQ(ret, CATEGORY_DEFAULT); +} + +/** +* @tc.name : Test AudioActiveDevice. +* @tc.number: WriteOutputRouteChangeEvent_001. +* @tc.desc : Test WriteOutputRouteChangeEvent. +*/ +HWTEST_F(AudioActiveDeviceUnitTest, WriteOutputRouteChangeEvent_001, TestSize.Level1) +{ + std::shared_ptr deviceDescriptor = std::make_shared(); + deviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + AudioStreamDeviceChangeReason reason = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE; + auto audioActiveDevice = std::make_shared(); + + audioActiveDevice->WriteOutputRouteChangeEvent(deviceDescriptor, reason); + EXPECT_EQ(deviceDescriptor->deviceId_, 0); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..7f405c1b921e0cf76727fc802f92c8bb768c11f1 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_ADAPTER_MANAGER_EXT_UNIT_TEST_H +#define AUDIO_ADAPTER_MANAGER_EXT_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_adapter_manager.h" +#include "audio_interrupt_service.h" +#include "audio_policy_server_handler.h" +#include "audio_zone_service.h" +#include "audio_volume.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioAdapterManagerExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + + void SetUp() override + { + std::shared_ptr handler = std::make_shared(); + std::shared_ptr interruptService = std::make_shared(); + AudioZoneService::GetInstance().Init(handler, interruptService); + AudioZoneContext context; + zoneId1_ = AudioZoneService::GetInstance().CreateAudioZone("TestZone1", context, 0); + zoneId2_ = AudioZoneService::GetInstance().CreateAudioZone("TestZone2", context, 0); + } + + void TearDown() override + { + zoneId1_ = 0; + zoneId2_ = 0; + AudioZoneService::GetInstance().DeInit(); + } + + int32_t zoneId1_ = 0; + int32_t zoneId2_ = 0; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_ADAPTER_MANAGER_EXT_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..207d2778a1b9be74b75c1585474b770504d9556e --- /dev/null +++ b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp @@ -0,0 +1,460 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include "audio_policy_utils.h" +#include "audio_adapter_manager_ext_unit_test.h" +#include "audio_stream_descriptor.h" +#include "audio_interrupt_service.h" +#include "audio_adapter_manager_handler.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +static AudioAdapterManager *audioAdapterManager_; + +void AudioAdapterManagerExtUnitTest::SetUpTestCase(void) {} +void AudioAdapterManagerExtUnitTest::TearDownTestCase(void) {} + +std::shared_ptr GetInterruptServiceTest() +{ + return std::make_shared(); +} + +/** + * @tc.name: SetAudioVolume_001 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_001, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + adapterManager->isAbsVolumeScene_ = true; + VolumeUtils::isPCVolumeEnable_ = true; + float temp = 1.0f; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_MUSIC, temp); + ); +} + +/** + * @tc.name: SetAudioVolume_002 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_002, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; + adapterManager->currentActiveDevice_.networkId_ = ""; + float temp = 1.0f; + VolumeUtils::isPCVolumeEnable_ = true; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_MUSIC, temp); + ); +} + +/** + * @tc.name: SetAudioVolume_003 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_003, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK; + float temp = 1.0f; + VolumeUtils::isPCVolumeEnable_ = true; + adapterManager->isSleVoiceStatus_ = false; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_MUSIC, temp); + ); +} + +/** + * @tc.name: SetAudioVolume_004 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_004, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK; + float temp = 1.0f; + VolumeUtils::isPCVolumeEnable_ = false; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_VOICE_COMMUNICATION, temp); + ); +} + +/** + * @tc.name: SetAudioVolumeThree_001 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolumeThree_001, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + desc->networkId_ = ""; + AudioStreamType streamType = STREAM_MUSIC; + float volumeDb = 0.0f; + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + EXPECT_NO_THROW( + audioAdapterManager->SetAudioVolume(desc, streamType, volumeDb); + ); +} + +/** + * @tc.name: SetAudioVolumeThree_002 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolumeThree_002, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + AudioStreamType streamType = STREAM_MUSIC; + desc->networkId_ = "LocalDevice"; + float volumeDb = 0.0f; + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + EXPECT_NO_THROW( + audioAdapterManager->SetAudioVolume(desc, streamType, volumeDb); + ); +} + +/** + * @tc.name: SetAudioVolumeThree_003 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolumeThree_003, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + AudioStreamType streamType = STREAM_MUSIC; + desc->networkId_ = "LocalDevice"; + float volumeDb = 0.0f; + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + EXPECT_NO_THROW( + audioAdapterManager->SetAudioVolume(desc, streamType, volumeDb); + ); +} + +/** + * @tc.name: SetOffloadVolume_001 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_001, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_MUSIC; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetOffloadVolume_002 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_002, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_SPEECH; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetOffloadVolume_003 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_003, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_RING; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + uint32_t sessionId = MIN_STREAMID + 1; + audioAdapterManager->SetOffloadSessionId(sessionId); + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetOffloadVolume_004 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_004, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_RING; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + uint32_t sessionId = 1; + audioAdapterManager->SetOffloadSessionId(sessionId); + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetDoubleRingVolumeDb_002 + * @tc.desc: Test SetDoubleRingVolumeDb + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetDoubleRingVolumeDb_002, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + audioAdapterManager->Init(); + + uint32_t sessionId = MIN_STREAMID + 1; + audioAdapterManager->SetOffloadSessionId(sessionId); + audioAdapterManager->ResetOffloadSessionId(); + audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; + AudioStreamType streamType = STREAM_RING; + int32_t volumeLevel = 5; + audioAdapterManager->useNonlinearAlgo_ = true; + int32_t result = audioAdapterManager->SetDoubleRingVolumeDb(streamType, volumeLevel); + EXPECT_EQ(result, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_001 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_001, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + int32_t res = audioAdapterManager->SetRingerModeInternal(RINGER_MODE_VIBRATE); + EXPECT_EQ(res, SUCCESS); + bool mute = true; + AudioStreamType streamType = STREAM_RING; + StreamUsage streamUsage = STREAM_USAGE_ALARM; + DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; + int32_t ret = audioAdapterManager->SetStreamMuteInternal(desc, streamType, mute, streamUsage, deviceType); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_002 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_002, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + int32_t res = audioAdapterManager->SetRingerModeInternal(RINGER_MODE_VIBRATE); + EXPECT_EQ(res, SUCCESS); + bool mute = false; + AudioStreamType streamType = STREAM_RING; + StreamUsage streamUsage = STREAM_USAGE_ALARM; + DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; + int32_t ret = audioAdapterManager->SetStreamMuteInternal(desc, streamType, mute, streamUsage, deviceType); + EXPECT_NE(ret, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_003 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_003, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + audioAdapterManager->Init(); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + int32_t res = audioAdapterManager->SetRingerModeInternal(RINGER_MODE_VIBRATE); + EXPECT_EQ(res, SUCCESS); + bool mute = false; + AudioStreamType streamType = STREAM_RING; + StreamUsage streamUsage = STREAM_USAGE_ALARM; + DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; + int32_t ret = audioAdapterManager->SetStreamMuteInternal(desc, streamType, mute, streamUsage, deviceType); + EXPECT_NE(ret, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_004 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_004, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.volumeBehavior_.databaseVolumeName = "databaseVolumeName"; + VolumeUtils::isPCVolumeEnable_ = true; + adapterManager->currentActiveDevice_.volumeBehavior_.isVolumeControlDisabled = false; + EXPECT_NO_THROW( + adapterManager->SetStreamMuteInternal(STREAM_MUSIC, false, STREAM_USAGE_MEDIA, DEVICE_TYPE_NONE, ""); + ); +} + +/** + * @tc.name: SetAppRingMuted_001 + * @tc.desc: Test SetAppRingMuted + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAppRingMuted_001, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, true), SUCCESS); + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, false), SUCCESS); +} + +/** + * @tc.name: IsAppRingMuted_001 + * @tc.desc: Test IsAppRingMuted + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, IsAppRingMuted_001, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + auto &adapterManager = AudioAdapterManager::GetInstance(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + desc->networkId_ = "NotLocalDevice"; + desc->deviceType_ = DEVICE_TYPE_SPEAKER; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices); + + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, true), SUCCESS); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(42), true); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(43), false); + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, false), SUCCESS); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(42), false); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(43), false); +} + +/** + * @tc.name: GetVolumeAdjustZoneId_001 + * @tc.desc: Test GetVolumeAdjustZoneId + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, GetVolumeAdjustZoneId_001, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + auto &adapterManager = AudioAdapterManager::GetInstance(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices); + AudioConnectedDevice::GetInstance().AddConnectedDevice(desc); + AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc); + ASSERT_EQ(adapterManager.GetVolumeAdjustZoneId(), 0); + ASSERT_EQ(adapterManager.SetAdjustVolumeForZone(zoneId1_), SUCCESS); + ASSERT_EQ(adapterManager.GetVolumeAdjustZoneId(), zoneId1_); +} + +/** + * @tc.name: SetAdjustVolumeForZone_002 + * @tc.desc: Test SetAdjustVolumeForZone + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAdjustVolumeForZone_002, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + auto &adapterManager = AudioAdapterManager::GetInstance(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices); + AudioConnectedDevice::GetInstance().AddConnectedDevice(desc); + AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc); + ASSERT_EQ(adapterManager.SetAdjustVolumeForZone(zoneId1_), SUCCESS); + ASSERT_EQ(adapterManager.GetVolumeAdjustZoneId(), zoneId1_); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_unit_test.cpp index 1248f09dce8ccb4cd39af54d26faba2eb2b545e0..35363a0baed0137fba85875e985a6bbd6fb683f1 100644 --- a/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_unit_test.cpp @@ -718,5 +718,20 @@ HWTEST_F(AudioAdapterManagerUnitTest, GetMinVolumeLevel_004, TestSize.Level1) EXPECT_EQ(ret, audioAdapterManager->minVolumeIndexMap_[STREAM_MUSIC]); } +/** + * @tc.name: Test GetAudioSourceAttr + * @tc.number: GetAudioSourceAttr_001 + * @tc.type: FUNC + * @tc.desc: when inof layout is not empty, passthrought layout to attr + */ +HWTEST_F(AudioAdapterManagerUnitTest, GetAudioSourceAttr_001, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + AudioModuleInfo info; + info.channelLayout = "263"; // 263 = 100000111 + IAudioSourceAttr attr = audioAdapterManager->GetAudioSourceAttr(info); + EXPECT_EQ(attr.channelLayout, 263); // 263 = 100000111 +} + } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_background_manager_unit_test/src/audio_background_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_background_manager_unit_test/src/audio_background_manager_unit_test.cpp index cc04c6b9a0e0da8800a228147a25e2874d115dd1..70d1aeceef05c987e70f2b98cd91e12cb4826510 100644 --- a/services/audio_policy/test/unittest/audio_background_manager_unit_test/src/audio_background_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_background_manager_unit_test/src/audio_background_manager_unit_test.cpp @@ -1102,5 +1102,45 @@ HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_044, TestSize.Leve EXPECT_EQ(ret, false); EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false); } + +/** + * @tc.name : Test WriteAppStateChangeSysEvent API + * @tc.type : FUNC + * @tc.number: AudioBackgroundManager_045 + * @tc.desc : Test WriteAppStateChangeSysEvent + */ +HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_045, TestSize.Level1) +{ + AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr; + audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance(); + ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr); + + int32_t pid = 0; + AppState appState; + appState.isFreeze = 1; + appState.isBack = 1; + appState.hasSession = 1; + appState.hasBackTask = 1; + appState.isBinder = 1; + + audioBackgroundManagerTest_->appStatesMap_.clear(); + EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true); + + audioBackgroundManagerTest_->WriteAppStateChangeSysEvent(pid, appState, 1); + sleep(1000); + + audioBackgroundManagerTest_->RecoryAppState(); + EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.size(), 1); + + auto it = audioBackgroundManagerTest_->appStatesMap_.find(pid); + EXPECT_EQ(it != audioBackgroundManagerTest_->appStatesMap_.end(), true); + + AppState recoryState = it->second; + EXPECT_EQ(appState.isFreeze, recoryState.isFreeze); + EXPECT_EQ(appState.isBack, recoryState.isBack); + EXPECT_EQ(appState.hasSession, recoryState.hasSession); + EXPECT_EQ(appState.hasBackTask, recoryState.hasBackTask); + EXPECT_EQ(appState.isBinder, recoryState.isBinder); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_unit_test.cpp b/services/audio_policy/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_unit_test.cpp index bf6a720a2f837f7dc361e4d7ee6ddfa064321b6c..a349c397cc3dd869c2e26cfd4bf33f035c2a3f33 100644 --- a/services/audio_policy/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_capturer_session_unit_test/src/audio_capturer_session_unit_test.cpp @@ -14,6 +14,7 @@ */ #include "audio_capturer_session_unit_test.h" + using namespace testing::ext; namespace OHOS { diff --git a/services/audio_policy/test/unittest/audio_client_tracker_callback_listener_unit_test/include/audio_client_tracker_callback_listener_unit_test.h b/services/audio_policy/test/unittest/audio_client_tracker_callback_listener_unit_test/include/audio_client_tracker_callback_listener_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..2235bfe9990b57e74e02cda0a257cd728bb68fa2 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_client_tracker_callback_listener_unit_test/include/audio_client_tracker_callback_listener_unit_test.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_CLIENT_TRACKER_CALLBACK_LISTENER_UNIT_TEST_H +#define AUDIO_CLIENT_TRACKER_CALLBACK_LISTENER_UNIT_TEST_H + +#include "audio_client_tracker_callback_listener.h" +#include "audio_client_tracker_callback_service.h" +#include "gtest/gtest.h" +#include "gmock/gmock.h" + +namespace OHOS { +namespace AudioStandard { + +using namespace testing::ext; + +class AudioClientTrackerCallbackListenerUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); + +private: + sptr listener_; + StreamSetStateEventInternal streamSetStateEventInternal_; + std::shared_ptr clientTracker_; +}; + +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_CLIENT_TRACKER_CALLBACK_LISTENER_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_client_tracker_callback_listener_unit_test/src/audio_client_tracker_callback_listener_unit_test.cpp b/services/audio_policy/test/unittest/audio_client_tracker_callback_listener_unit_test/src/audio_client_tracker_callback_listener_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..68393599e58cd56e17445b3aef86cfac23ff4ca2 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_client_tracker_callback_listener_unit_test/src/audio_client_tracker_callback_listener_unit_test.cpp @@ -0,0 +1,285 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_client_tracker_callback_listener_unit_test.h" + +namespace OHOS { +namespace AudioStandard { +void AudioClientTrackerCallbackListenerUnitTest::SetUpTestCase(void) {} + +void AudioClientTrackerCallbackListenerUnitTest::TearDownTestCase(void) {} + +void AudioClientTrackerCallbackListenerUnitTest::SetUp(void) +{ + listener_ = new AudioClientTrackerCallbackService(); + clientTracker_ = std::make_shared(listener_); + streamSetStateEventInternal_ = {}; +} + +void AudioClientTrackerCallbackListenerUnitTest::TearDown(void) +{ + if (listener_ != nullptr) { + delete listener_; + listener_ = nullptr; + } +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: MuteStreamImpl_01 +* @tc.desc : Test MuteStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, MuteStreamImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + ASSERT_NE(clientTracker_, nullptr); + EXPECT_NO_THROW( + clientTracker_->MuteStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: MuteStreamImpl_02 +* @tc.desc : Test MuteStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, MuteStreamImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + EXPECT_NO_THROW( + clientTracker->MuteStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: UnmuteStreamImpl_01 +* @tc.desc : Test UnmuteStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, UnmuteStreamImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + EXPECT_NO_THROW( + clientTracker_->UnmuteStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: UnmuteStreamImpl_02 +* @tc.desc : Test UnmuteStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, UnmuteStreamImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + EXPECT_NO_THROW( + clientTracker->UnmuteStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: PausedStreamImpl_01 +* @tc.desc : Test PausedStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, PausedStreamImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + EXPECT_NO_THROW( + clientTracker_->PausedStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: PausedStreamImpl_02 +* @tc.desc : Test PausedStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, PausedStreamImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + EXPECT_NO_THROW( + clientTracker->PausedStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: ResumeStreamImpl_01 +* @tc.desc : Test ResumeStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, ResumeStreamImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + EXPECT_NO_THROW( + clientTracker_->ResumeStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: ResumeStreamImpl_02 +* @tc.desc : Test ResumeStreamImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, ResumeStreamImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + EXPECT_NO_THROW( + clientTracker->ResumeStreamImpl(streamSetStateEventInternal_); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: SetLowPowerVolumeImpl_01 +* @tc.desc : Test SetLowPowerVolumeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, SetLowPowerVolumeImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + float volume = 0.5f; + EXPECT_NO_THROW( + clientTracker_->SetLowPowerVolumeImpl(volume); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: SetLowPowerVolumeImpl_02 +* @tc.desc : Test SetLowPowerVolumeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, SetLowPowerVolumeImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + float volume = 0.5f; + EXPECT_NO_THROW( + clientTracker->SetLowPowerVolumeImpl(volume); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: GetLowPowerVolumeImpl_01 +* @tc.desc : Test GetLowPowerVolumeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, GetLowPowerVolumeImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + float volume = 0.5f; + EXPECT_NO_THROW( + clientTracker_->GetLowPowerVolumeImpl(volume); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: GetLowPowerVolumeImpl_02 +* @tc.desc : Test GetLowPowerVolumeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, GetLowPowerVolumeImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + float volume = 0.5f; + EXPECT_NO_THROW( + clientTracker->GetLowPowerVolumeImpl(volume); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: GetSingleStreamVolumeImpl_01 +* @tc.desc : Test GetSingleStreamVolumeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, GetSingleStreamVolumeImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + float volume = 0.5f; + EXPECT_NO_THROW( + clientTracker_->GetSingleStreamVolumeImpl(volume); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: GetSingleStreamVolumeImpl_02 +* @tc.desc : Test GetSingleStreamVolumeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, GetSingleStreamVolumeImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + float volume = 0.5f; + EXPECT_NO_THROW( + clientTracker->GetSingleStreamVolumeImpl(volume); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: SetOffloadModeImpl_01 +* @tc.desc : Test SetOffloadModeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, SetOffloadModeImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + int32_t state = 1; + bool isAppBack = false; + EXPECT_NO_THROW( + clientTracker_->SetOffloadModeImpl(state, isAppBack); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: SetOffloadModeImpl_02 +* @tc.desc : Test SetOffloadModeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, SetOffloadModeImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + int32_t state = 1; + bool isAppBack = false; + EXPECT_NO_THROW( + clientTracker->SetOffloadModeImpl(state, isAppBack); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: UnsetOffloadModeImpl_01 +* @tc.desc : Test UnsetOffloadModeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, UnsetOffloadModeImpl_01, TestSize.Level1) +{ + ASSERT_NE(listener_, nullptr); + EXPECT_NO_THROW( + clientTracker_->UnsetOffloadModeImpl(); + ); +} + +/** +* @tc.name : Test ClientTrackerCallbackListener. +* @tc.number: UnsetOffloadModeImpl_02 +* @tc.desc : Test UnsetOffloadModeImpl. +*/ +HWTEST_F(AudioClientTrackerCallbackListenerUnitTest, UnsetOffloadModeImpl_02, TestSize.Level1) +{ + std::shared_ptr clientTracker = std::make_shared(nullptr); + EXPECT_NO_THROW( + clientTracker->UnsetOffloadModeImpl(); + ); +} + +} // AudioStandardnamespace +} // OHOSnamespace diff --git a/services/audio_policy/test/unittest/audio_client_tracker_callback_service_unit_test/include/audio_client_tracker_callback_service_unit_test.h b/services/audio_policy/test/unittest/audio_client_tracker_callback_service_unit_test/include/audio_client_tracker_callback_service_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..101d7db5459d5a774463d5f706cd7706aa79f0a4 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_client_tracker_callback_service_unit_test/include/audio_client_tracker_callback_service_unit_test.h @@ -0,0 +1,156 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_CLIENT_TRACKER_CALLBACK_SERVICE_UNIT_TEST_H +#define AUDIO_CLIENT_TRACKER_CALLBACK_SERVICE_UNIT_TEST_H + +#include "audio_client_tracker_callback_service.h" +#include "audio_stream_manager.h" +#include "standard_client_tracker_stub.h" +#include "gmock/gmock.h" + +namespace OHOS { +namespace AudioStandard { +class AudioClientTrackerCallbackServiceUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; + +class MockAudioClientTracker : public AudioClientTracker { +public: + MockAudioClientTracker() = default; + virtual ~MockAudioClientTracker() = default; + + void MuteStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) override + { + (void)streamSetStateEventInternal; + hasMuteStreamImplMonitor_ = true; + } + + void UnmuteStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) override + { + (void)streamSetStateEventInternal; + hasUnmuteStreamImplMonitor_ = true; + } + + void PausedStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) override + { + (void)streamSetStateEventInternal; + hasPausedStreamImplMonitor_ = true; + } + + void ResumeStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) override + { + (void)streamSetStateEventInternal; + hasResumeStreamImplMonitor_ = true; + } + + void SetLowPowerVolumeImpl(float volume) override + { + (void)volume; + hasSetLowPowerVolumeImplMonitor_ = true; + } + + void GetLowPowerVolumeImpl(float &volume) override + { + (void)volume; + hasGetLowPowerVolumeImplMonitor_ = true; + } + + void SetOffloadModeImpl(int32_t state, bool isAppBack) override + { + (void)state; + (void)isAppBack; + hasSetOffloadModeImplMonitor_ = true; + } + + void UnsetOffloadModeImpl() override + { + hasUnsetOffloadModeImplMonitor_ = true; + } + + void GetSingleStreamVolumeImpl(float &volume) override + { + (void)volume; + hasGetSingleStreamVolumeImplMonitor_ = true; + } + + bool GetMuteStreamImplMonitor() const + { + return hasMuteStreamImplMonitor_; + } + + bool GetUnmuteStreamImplMonitor() const + { + return hasUnmuteStreamImplMonitor_; + } + + bool GetPausedStreamImplMonitor() const + { + return hasPausedStreamImplMonitor_; + } + + bool GetResumeStreamImplMonitor() const + { + return hasResumeStreamImplMonitor_; + } + + bool GetSetLowPowerVolumeImplMonitor() const + { + return hasSetLowPowerVolumeImplMonitor_; + } + + bool GetGetLowPowerVolumeImplMonitor() const + { + return hasGetLowPowerVolumeImplMonitor_; + } + + bool GetSetOffloadModeImplMonitor() const + { + return hasSetOffloadModeImplMonitor_; + } + + bool GetUnsetOffloadModeImplMonitor() const + { + return hasUnsetOffloadModeImplMonitor_; + } + + bool GetGetSingleStreamVolumeImplMonitor() const + { + return hasGetSingleStreamVolumeImplMonitor_; + } + +private: + bool hasMuteStreamImplMonitor_{false}; + bool hasUnmuteStreamImplMonitor_{false}; + bool hasPausedStreamImplMonitor_{false}; + bool hasResumeStreamImplMonitor_{false}; + bool hasSetLowPowerVolumeImplMonitor_{false}; + bool hasGetLowPowerVolumeImplMonitor_{false}; + bool hasSetOffloadModeImplMonitor_{false}; + bool hasUnsetOffloadModeImplMonitor_{false}; + bool hasGetSingleStreamVolumeImplMonitor_{false}; +}; +} // namespace AudioStandard +} // namespace OHOS + +#endif // AUDIO_CLIENT_TRACKER_CALLBACK_SERVICE_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_client_tracker_callback_service_unit_test/src/audio_client_tracker_callback_service_unit_test.cpp b/services/audio_policy/test/unittest/audio_client_tracker_callback_service_unit_test/src/audio_client_tracker_callback_service_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..31f07b07db5ae5c5f2cce0092ed40cd2b06fcd1f --- /dev/null +++ b/services/audio_policy/test/unittest/audio_client_tracker_callback_service_unit_test/src/audio_client_tracker_callback_service_unit_test.cpp @@ -0,0 +1,346 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include "audio_client_tracker_callback_service_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +const float VOLUME_TEST = 0.1f; +const int32_t NUM = 10; + +void AudioClientTrackerCallbackServiceUnitTest::SetUpTestCase(void) {} +void AudioClientTrackerCallbackServiceUnitTest::TearDownTestCase(void) {} +void AudioClientTrackerCallbackServiceUnitTest::SetUp(void) {} +void AudioClientTrackerCallbackServiceUnitTest::TearDown(void) {} + + +/** +* @tc.name : AudioClientTrackerCallbackService_001 +* @tc.desc : MuteStreamImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_001, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->MuteStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_002 +* @tc.desc : MuteStreamImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_002, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->MuteStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(tracker->GetMuteStreamImplMonitor(), true); + callback->UnsetClientTrackerCallback(); + callback = nullptr; +} + +/** +* @tc.name : AudioClientTrackerCallbackService_003 +* @tc.desc : UnmuteStreamImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_003, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->UnmuteStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_004 +* @tc.desc : UnmuteStreamImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_004, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->UnmuteStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); + callback->UnsetClientTrackerCallback(); + EXPECT_EQ(tracker->GetUnmuteStreamImplMonitor(), true); + callback = nullptr; +} + +/** +* @tc.name : AudioClientTrackerCallbackService_005 +* @tc.desc : PausedStreamImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_005, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->PausedStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); + callback = nullptr; +} + +/** +* @tc.name : AudioClientTrackerCallbackService_006 +* @tc.desc : PausedStreamImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_006, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->PausedStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(tracker->GetPausedStreamImplMonitor(), true); + callback->UnsetClientTrackerCallback(); + callback = nullptr; +} + +/** +* @tc.name : AudioClientTrackerCallbackService_007 +* @tc.desc : SetLowPowerVolumeImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_007, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + int32_t result = callback->SetLowPowerVolumeImpl(VOLUME); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_008 +* @tc.desc : SetLowPowerVolumeImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_008, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + int32_t result = callback->SetLowPowerVolumeImpl(VOLUME); + EXPECT_EQ(result, SUCCESS); + callback->UnsetClientTrackerCallback(); + EXPECT_EQ(tracker->GetSetLowPowerVolumeImplMonitor(), true); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_009 +* @tc.desc : ResumeStreamImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_009, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->ResumeStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_010 +* @tc.desc : ResumeStreamImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_010, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + StreamSetStateEventInternal streamSetStateEventInternal; + int32_t result = callback->ResumeStreamImpl(streamSetStateEventInternal); + EXPECT_EQ(result, SUCCESS); + callback->UnsetClientTrackerCallback(); + EXPECT_EQ(tracker->GetResumeStreamImplMonitor(), true); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_011 +* @tc.desc : SetOffloadModeImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_011, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + int32_t result = callback->SetOffloadModeImpl(NUM, true); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_012 +* @tc.desc : SetOffloadModeImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_012, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + int32_t result = callback->SetOffloadModeImpl(NUM, true); + EXPECT_EQ(result, SUCCESS); + callback->UnsetClientTrackerCallback(); + EXPECT_EQ(tracker->GetSetOffloadModeImplMonitor(), true); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_013 +* @tc.desc : UnsetOffloadModeImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_013, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + int32_t result = callback->UnsetOffloadModeImpl(); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_014 +* @tc.desc : UnsetOffloadModeImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_014, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + int32_t result = callback->UnsetOffloadModeImpl(); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(tracker->GetUnsetOffloadModeImplMonitor(), true); + callback->UnsetClientTrackerCallback(); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_015 +* @tc.desc : GetLowPowerVolumeImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_015, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + float ret = 0.0f; + int32_t result = callback->GetLowPowerVolumeImpl(ret); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_016 +* @tc.desc : GetLowPowerVolumeImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_016, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + float ret = 0.0f; + int32_t result = callback->GetLowPowerVolumeImpl(ret); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(tracker->GetGetLowPowerVolumeImplMonitor(), true); + callback->UnsetClientTrackerCallback(); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_017 +* @tc.desc : GetSingleStreamVolumeImpl callback is null. +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_017, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + std::weak_ptr nullWeakTracker; + callback->SetClientTrackerCallback(nullWeakTracker); + float ret = 0.0f; + int32_t result = callback->GetSingleStreamVolumeImpl(ret); + EXPECT_EQ(result, SUCCESS); +} + +/** +* @tc.name : AudioClientTrackerCallbackService_018 +* @tc.desc : GetSingleStreamVolumeImpl +* @tc.type: FUNC +* @tc.require: #I5Y4MZ +*/ +HWTEST_F(AudioClientTrackerCallbackServiceUnitTest, AudioClientTrackerCallbackService_018, TestSize.Level1) +{ + sptr callback = new(std::nothrow) AudioClientTrackerCallbackService(); + auto tracker = std::make_shared(); + std::weak_ptr weakTracker(tracker); + callback->SetClientTrackerCallback(weakTracker); + float ret = 0.0f; + int32_t result = callback->GetSingleStreamVolumeImpl(ret); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(tracker->GetGetSingleStreamVolumeImplMonitor(), true); + callback->UnsetClientTrackerCallback(); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_concurrency_service_unit_test/src/audio_concurrency_service_unit_test.cpp b/services/audio_policy/test/unittest/audio_concurrency_service_unit_test/src/audio_concurrency_service_unit_test.cpp index 1e7c48ad698c5e6454a5c9ba7bb157cecbe825d6..7e4c1f12984d9c995dc2d878e08b0b27fc244c67 100644 --- a/services/audio_policy/test/unittest/audio_concurrency_service_unit_test/src/audio_concurrency_service_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_concurrency_service_unit_test/src/audio_concurrency_service_unit_test.cpp @@ -27,17 +27,5 @@ void AudioConcurrencyServiceUnitTest::SetUpTestCase(void) {} void AudioConcurrencyServiceUnitTest::TearDownTestCase(void) {} void AudioConcurrencyServiceUnitTest::SetUp(void) {} void AudioConcurrencyServiceUnitTest::TearDown(void) {} - -/** -* @tc.name : Test AudioInputThread. -* @tc.number: AudioConcurrencyService_016. -* @tc.desc : Test ActivateAudioConcurrency. -*/ -HWTEST_F(AudioConcurrencyServiceUnitTest, AudioConcurrencyService_001, TestSize.Level1) -{ - auto audioConcurrencyService = std::make_shared(); - auto result = audioConcurrencyService->GetConcurrencyMap(); - EXPECT_EQ(result.size(), 0); -} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_core_service_private_unit_test/include/audio_core_service_private_unit_test.h b/services/audio_policy/test/unittest/audio_core_service_private_unit_test/include/audio_core_service_private_unit_test.h index e3989d85a2885ffe9ded88aa4c4595e09f0c050a..f5b400639e2b33aba8369de75f66c9651f34294a 100644 --- a/services/audio_policy/test/unittest/audio_core_service_private_unit_test/include/audio_core_service_private_unit_test.h +++ b/services/audio_policy/test/unittest/audio_core_service_private_unit_test/include/audio_core_service_private_unit_test.h @@ -25,13 +25,16 @@ namespace AudioStandard { class AudioCoreServicePrivateTest : public testing::Test { public: // SetUpTestCase: Called before all test cases - static void SetUpTestCase(void); + static void SetUpTestCase(void) {}; // TearDownTestCase: Called after all test case - static void TearDownTestCase(void); + static void TearDownTestCase(void) {}; // SetUp: Called before each test cases void SetUp(void); // TearDown: Called after each test cases void TearDown(void); + +private: + std::shared_ptr testCoreService_ = nullptr; }; } // namespace AudioStandard diff --git a/services/audio_policy/test/unittest/audio_core_service_private_unit_test/src/audio_core_service_private_unit_test.cpp b/services/audio_policy/test/unittest/audio_core_service_private_unit_test/src/audio_core_service_private_unit_test.cpp index 561ff7d4a24808fb9d2ee36740136fd1685f5165..880f661d36417163048bb512e66bb6cfa35ce935 100644 --- a/services/audio_policy/test/unittest/audio_core_service_private_unit_test/src/audio_core_service_private_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_core_service_private_unit_test/src/audio_core_service_private_unit_test.cpp @@ -14,6 +14,7 @@ */ #include "audio_core_service_private_unit_test.h" + using namespace testing::ext; namespace OHOS { @@ -21,13 +22,26 @@ namespace AudioStandard { static const int32_t BLUETOOTH_FETCH_RESULT_CONTINUE = 1; static const int32_t BLUETOOTH_FETCH_RESULT_ERROR = 2; +static const uint32_t TEST_STREAM_1_SESSION_ID = 100001; +static const uint32_t TEST_STREAM_2_SESSION_ID = 100002; + +void AudioCoreServicePrivateTest::SetUp(void) +{ + testCoreService_ = std::make_shared(); + testCoreService_->Init(); +} + +void AudioCoreServicePrivateTest::TearDown(void) +{ + testCoreService_ = nullptr; +} /** * @tc.name : Test AudioCoreService. * @tc.number: AudioCoreServicePrivate_001 * @tc.desc : Test AudioCoreService::GetEncryptAddr() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -43,7 +57,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_001, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_002 * @tc.desc : Test AudioCoreService::GetEncryptAddr() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -59,7 +73,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_002, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_003 * @tc.desc : Test AudioCoreService::GetEncryptAddr() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_003, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_003, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -75,7 +89,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_003, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_005 * @tc.desc : Test AudioCoreService::ScoInputDeviceFetchedForRecongnition() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_005, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_005, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -93,7 +107,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_005, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_006 * @tc.desc : Test AudioCoreService::ScoInputDeviceFetchedForRecongnition() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_006, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_006, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -111,7 +125,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_006, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_007 * @tc.desc : Test AudioCoreService::ScoInputDeviceFetchedForRecongnition() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_007, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_007, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -129,7 +143,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_007, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_008 * @tc.desc : Test AudioCoreService::BluetoothScoFetch() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_008, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_008, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -148,7 +162,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_008, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_009 * @tc.desc : Test AudioCoreService::CheckModemScene() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_009, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_009, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -166,7 +180,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_009, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_010 * @tc.desc : Test AudioCoreService::CheckModemScene() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_010, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_010, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -188,7 +202,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_010, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_011 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_011, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_011, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -207,7 +221,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_011, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_012 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_012, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_012, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -226,7 +240,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_012, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_013 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_013, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_013, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -244,7 +258,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_013, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_014 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_014, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_014, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -262,7 +276,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_014, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_015 * @tc.desc : Test AudioCoreService::BluetoothDeviceFetchOutputHandle() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_015, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_015, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -281,7 +295,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_015, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_016 * @tc.desc : Test AudioCoreService::BluetoothDeviceFetchOutputHandle() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_016, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_016, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -303,7 +317,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_016, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_017 * @tc.desc : Test AudioCoreService::BluetoothDeviceFetchOutputHandle() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_017, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_017, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -325,7 +339,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_017, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_018 * @tc.desc : Test AudioCoreService::ActivateA2dpDeviceWhenDescEnabled() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_018, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_018, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -344,7 +358,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_018, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_019 * @tc.desc : Test AudioCoreService::ActivateA2dpDeviceWhenDescEnabled() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_019, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_019, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -363,7 +377,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_019, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_020 * @tc.desc : Test AudioCoreService::ActivateA2dpDeviceWhenDescEnabled() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_020, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_020, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -382,7 +396,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_020, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_022 * @tc.desc : Test AudioCoreService::LoadA2dpModule() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_022, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_022, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -402,7 +416,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_022, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_023 * @tc.desc : Test AudioCoreService::ReloadA2dpAudioPort() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_023, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_023, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -425,7 +439,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_023, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_024 * @tc.desc : Test AudioCoreService::ReloadA2dpAudioPort() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_024, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_024, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -448,7 +462,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_024, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_025 * @tc.desc : Test AudioCoreService::GetA2dpModuleInfo() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_025, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_025, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -467,7 +481,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_025, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_026 * @tc.desc : Test AudioCoreService::GetA2dpModuleInfo() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_026, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_026, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -486,7 +500,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_026, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_027 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_027, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_027, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -513,7 +527,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_027, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_028 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_028, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_028, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -543,7 +557,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_028, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_029 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_029, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_029, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -570,7 +584,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_029, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_030 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_030, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_030, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -599,7 +613,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_030, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_031 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_031, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_031, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -625,7 +639,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_031, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_032 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_032, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_032, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -651,7 +665,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_032, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_033 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_033, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_033, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -677,7 +691,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_033, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_034 * @tc.desc : Test AudioCoreService::IsSameDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_034, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_034, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -703,7 +717,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_034, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_037 * @tc.desc : Test AudioCoreService::ProcessOutputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_037, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_037, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -729,7 +743,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_037, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_038 * @tc.desc : Test AudioCoreService::ProcessOutputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_038, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_038, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -755,7 +769,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_038, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_039 * @tc.desc : Test AudioCoreService::ProcessOutputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_039, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_039, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -781,7 +795,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_039, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_040 * @tc.desc : Test AudioCoreService::ProcessOutputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_040, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_040, TestSize.Level1) { auto audioCoreService = std::make_shared(); EXPECT_NE(audioCoreService, nullptr); @@ -807,7 +821,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_040, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_043 * @tc.desc : Test AudioCoreService::BluetoothScoFetch */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_043, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_043, TestSize.Level1) { std::shared_ptr streamDesc = std::make_shared(); std::shared_ptr audioDeviceDescriptor = std::make_shared(); @@ -825,7 +839,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_043, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_044 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_044, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_044, TestSize.Level1) { AudioMode mode = AUDIO_MODE_RECORD; AudioStreamChangeInfo streamChangeInfo; @@ -844,7 +858,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_044, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_045 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_045, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_045, TestSize.Level1) { AudioMode mode = AUDIO_MODE_RECORD; AudioStreamChangeInfo streamChangeInfo; @@ -863,7 +877,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_045, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_046 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_046, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_046, TestSize.Level1) { AudioMode mode = AUDIO_MODE_RECORD; AudioStreamChangeInfo streamChangeInfo; @@ -882,7 +896,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_046, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_047 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_047, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_047, TestSize.Level1) { AudioMode mode = AUDIO_MODE_RECORD; AudioStreamChangeInfo streamChangeInfo; @@ -900,7 +914,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_047, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_048 * @tc.desc : Test AudioCoreService::HandleAudioCaptureState */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_048, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_048, TestSize.Level1) { AudioMode mode = AUDIO_MODE_PLAYBACK; AudioStreamChangeInfo streamChangeInfo; @@ -918,7 +932,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_048, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_049 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_049, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_049, TestSize.Level1) { auto audioCoreService = AudioCoreService::GetCoreService(); @@ -932,7 +946,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_049, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_050 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_050, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_050, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_EARPIECE; @@ -948,7 +962,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_050, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_051 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_051, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_051, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_SPEAKER; @@ -964,7 +978,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_051, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_052 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_052, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_052, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; @@ -980,7 +994,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_052, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_053 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_053, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_053, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_WIRED_HEADPHONES; @@ -996,7 +1010,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_053, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_054 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_054, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_054, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_USB_HEADSET; auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1011,7 +1025,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_054, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_055 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_055, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_055, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_DP; auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1026,7 +1040,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_055, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_056 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_056, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_056, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_SCO; auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1041,7 +1055,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_056, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_057 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_057, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_057, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1056,7 +1070,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_057, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_058 * @tc.desc : Test AudioCoreService::HasLowLatencyCapability */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_058, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_058, TestSize.Level1) { DeviceType deviceType = DEVICE_TYPE_DEFAULT; auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1071,7 +1085,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_058, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_059 * @tc.desc : Test AudioCoreService::GetRealUid */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_059, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_059, TestSize.Level1) { auto streamDesc = std::make_shared(); streamDesc->callerUid_ = 1013; @@ -1089,7 +1103,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_059, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_060 * @tc.desc : Test AudioCoreService::GetRealUid */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_060, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_060, TestSize.Level1) { auto streamDesc = std::make_shared(); auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1106,7 +1120,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_060, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_GetRealPid * @tc.desc : Test AudioCoreService::GetRealPid */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_GetRealPid, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_GetRealPid, TestSize.Level1) { auto streamDesc = std::make_shared(); streamDesc->callerUid_ = 1013; @@ -1125,7 +1139,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_GetRealPid, TestSize * @tc.number: AudioCoreServicePrivate_GetRealPid_02 * @tc.desc : Test AudioCoreService::GetRealPid */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_GetRealPid_02, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_GetRealPid_02, TestSize.Level1) { auto streamDesc = std::make_shared(); auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1142,7 +1156,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_GetRealPid_02, TestS * @tc.number: AudioCoreServicePrivate_061 * @tc.desc : Test AudioCoreService::UpdateRendererInfoWhenNoPermission */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_061, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_061, TestSize.Level1) { auto audioRendererChangeInfos = std::make_shared(); bool hasSystemPermission = true; @@ -1159,7 +1173,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_061, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_062 * @tc.desc : Test AudioCoreService::UpdateRendererInfoWhenNoPermission */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_062, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_062, TestSize.Level1) { auto audioRendererChangeInfos = std::make_shared(); bool hasSystemPermission = false; @@ -1176,7 +1190,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_062, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_063 * @tc.desc : Test AudioCoreService::UpdateRendererInfoWhenNoPermission */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_063, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_063, TestSize.Level1) { auto audioCapturerChangeInfos = std::make_shared(); bool hasSystemPermission = true; @@ -1193,7 +1207,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_063, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_064 * @tc.desc : Test AudioCoreService::UpdateRendererInfoWhenNoPermission */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_064, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_064, TestSize.Level1) { auto audioCapturerChangeInfos = std::make_shared(); bool hasSystemPermission = false; @@ -1210,7 +1224,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_064, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_065 * @tc.desc : Test AudioCoreService::GetFastControlParam */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_065, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_065, TestSize.Level1) { auto audioCoreService = AudioCoreService::GetCoreService(); audioCoreService->isFastControlled_ = true; @@ -1227,7 +1241,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_065, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_066 * @tc.desc : Test AudioCoreService::GetFastControlParam */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_066, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_066, TestSize.Level1) { auto audioCoreService = AudioCoreService::GetCoreService(); audioCoreService->isFastControlled_ = true; @@ -1244,7 +1258,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_066, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_067 * @tc.desc : Test AudioCoreService::NeedRehandleA2DPDevice */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_067, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_067, TestSize.Level1) { auto desc = std::make_shared(); @@ -1261,7 +1275,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_067, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_068 * @tc.desc : Test AudioCoreService::NeedRehandleA2DPDevice */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_068, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_068, TestSize.Level1) { auto desc = std::make_shared(); @@ -1281,7 +1295,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_068, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_069 * @tc.desc : Test AudioCoreService::NeedRehandleA2DPDevice */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_069, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_069, TestSize.Level1) { auto desc = std::make_shared(); @@ -1301,7 +1315,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_069, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_070 * @tc.desc : Test AudioCoreService::TriggerRecreateRendererStreamCallback */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_070, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_070, TestSize.Level1) { shared_ptr streamDesc = std::make_shared(); streamDesc->callerPid_ = 0; @@ -1333,7 +1347,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_070, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_071 * @tc.desc : Test AudioCoreService::TriggerRecreateRendererStreamCallback */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_071, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_071, TestSize.Level1) { shared_ptr streamDesc = std::make_shared(); streamDesc->callerPid_ = 0; @@ -1368,7 +1382,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_071, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_072 * @tc.desc : Test AudioCoreService::TriggerRecreateCapturerStreamCallback */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_072, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_072, TestSize.Level1) { std::shared_ptr streamDesc = std::make_shared(); streamDesc->sessionId_ = 0, @@ -1392,7 +1406,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_072, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_073 * @tc.desc : Test AudioCoreService::TriggerRecreateCapturerStreamCallback */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_073, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_073, TestSize.Level1) { std::shared_ptr streamDesc = std::make_shared(); streamDesc->sessionId_ = 123456, @@ -1419,7 +1433,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_073, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_074 * @tc.desc : Test AudioCoreService::HandleStreamStatusToCapturerState */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_074, TestSize.Level2) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_074, TestSize.Level2) { auto audioCoreService = AudioCoreService::GetCoreService(); @@ -1439,41 +1453,12 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_074, TestSize.Level2 EXPECT_EQ(state, CAPTURER_RELEASED); } -/** - * @tc.name : Test AudioCoreService. - * @tc.number: AudioCoreServicePrivate_075 - * @tc.desc : Test AudioCoreService::ProcessOutputPipeNew() - */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_075, TestSize.Level1) -{ - auto audioCoreService = std::make_shared(); - EXPECT_NE(audioCoreService, nullptr); - - std::shared_ptr pipeInfo = std::make_shared(); - std::shared_ptr audioStreamDescriptor = std::make_shared(); - audioStreamDescriptor->streamAction_ = AUDIO_STREAM_ACTION_MOVE; - audioStreamDescriptor->streamStatus_ = STREAM_STATUS_STARTED; - audioStreamDescriptor->appInfo_.appUid = AUDIO_ID; - pipeInfo->streamDescriptors_.push_back(audioStreamDescriptor); - uint32_t flag = 0; - AudioStreamDeviceChangeReasonExt::ExtEnum extEnum = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN; - AudioStreamDeviceChangeReasonExt reason(extEnum); - audioCoreService->pipeManager_ = std::make_shared(); - - std::shared_ptr audioDeviceDescriptor = std::make_shared(); - audioStreamDescriptor->newDeviceDescs_.push_back(audioDeviceDescriptor); - audioStreamDescriptor->oldDeviceDescs_.push_back(audioDeviceDescriptor); - - audioCoreService->ProcessOutputPipeNew(pipeInfo, flag, reason); - EXPECT_NE(audioCoreService->pipeManager_, nullptr); -} - /** * @tc.name : Test AudioCoreService. * @tc.number: AudioCoreServicePrivate_100 * @tc.desc : Test AudioCoreService::ProcessOutputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_100, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_100, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1501,7 +1486,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_100, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_101 * @tc.desc : Test AudioCoreService::ProcessOutputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_101, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_101, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1530,7 +1515,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_101, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_102 * @tc.desc : Test AudioCoreService::ProcessOutputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_102, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_102, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1560,7 +1545,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_102, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_103 * @tc.desc : Test AudioCoreService::ProcessOutputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_103, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_103, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1590,7 +1575,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_103, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_104 * @tc.desc : Test AudioCoreService::ProcessInputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_104, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_104, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1618,7 +1603,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_104, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_105 * @tc.desc : Test AudioCoreService::ProcessInputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_105, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_105, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1644,7 +1629,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_105, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_106 * @tc.desc : Test AudioCoreService::ProcessInputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_106, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_106, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1670,7 +1655,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_106, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_107 * @tc.desc : Test AudioCoreService::ProcessInputPipeNew() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_107, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_107, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1696,7 +1681,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_107, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_108 * @tc.desc : Test AudioCoreService::ProcessInputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_108, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_108, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1724,7 +1709,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_108, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_109 * @tc.desc : Test AudioCoreService::ProcessInputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_109, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_109, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1750,7 +1735,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_109, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_110 * @tc.desc : Test AudioCoreService::ProcessInputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_110, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_110, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1776,7 +1761,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_110, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_111 * @tc.desc : Test AudioCoreService::ProcessInputPipeUpdate() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_111, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_111, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1802,7 +1787,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_111, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_112 * @tc.desc : Test AudioCoreService::SwitchActiveA2dpDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_112, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_112, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1825,7 +1810,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_112, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_113 * @tc.desc : Test AudioCoreService::SwitchActiveA2dpDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_113, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_113, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1848,7 +1833,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_113, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_114 * @tc.desc : Test AudioCoreService::SwitchActiveA2dpDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_114, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_114, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1872,7 +1857,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_114, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_115 * @tc.desc : Test AudioCoreService::MoveToNewInputDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_115, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_115, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1893,7 +1878,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_115, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_116 * @tc.desc : Test AudioCoreService::MoveToNewInputDevice() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_116, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_116, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1915,7 +1900,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_116, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_117 * @tc.desc : Test AudioCoreService::IsNewDevicePlaybackSupported() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_117, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_117, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1935,7 +1920,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_117, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_118 * @tc.desc : Test AudioCoreService::IsNewDevicePlaybackSupported() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_118, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_118, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1952,7 +1937,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_118, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_119 * @tc.desc : Test AudioCoreService::IsNewDevicePlaybackSupported() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_119, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_119, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1974,7 +1959,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_119, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_120 * @tc.desc : Test AudioCoreService::IsNewDevicePlaybackSupported() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_120, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_120, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -1996,7 +1981,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_120, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_121 * @tc.desc : Test AudioCoreService::UpdateInputDeviceWhenStopping */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_121, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_121, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2024,7 +2009,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_121, TestSize.Level1 * @tc.number: IsFastAllowedTest_001 * @tc.desc : Test AudioCoreService::IsFastAllowed, return true when bundleName is null. */ -HWTEST(AudioCoreServicePrivateTest, IsFastAllowedTest_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsFastAllowedTest_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2037,7 +2022,7 @@ HWTEST(AudioCoreServicePrivateTest, IsFastAllowedTest_001, TestSize.Level1) * @tc.number: IsFastAllowedTest_002 * @tc.desc : Test AudioCoreService::IsFastAllowed, return true when bundleName is normal app. */ -HWTEST(AudioCoreServicePrivateTest, IsFastAllowedTest_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsFastAllowedTest_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2052,7 +2037,7 @@ HWTEST(AudioCoreServicePrivateTest, IsFastAllowedTest_002, TestSize.Level1) * @tc.number: HandleFetchOutputWhenNoRunningStream_001 * @tc.desc : Test AudioCoreService::HandleFetchOutputWhenNoRunningStream, fetch output when no running stream. */ -HWTEST(AudioCoreServicePrivateTest, HandleFetchOutputWhenNoRunningStream_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, HandleFetchOutputWhenNoRunningStream_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2065,7 +2050,7 @@ HWTEST(AudioCoreServicePrivateTest, HandleFetchOutputWhenNoRunningStream_001, Te * @tc.number: CheckModemScene_001 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to started if scene is AUDIO_SCENE_PHONE_CALL */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2090,7 +2075,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_001, TestSize.Level1) * @tc.number: CheckModemScene_002 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to stopped if scene is AUDIO_SCENE_DEFAULT */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2114,7 +2099,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_002, TestSize.Level1) * @tc.number: CheckModemScene_003 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to started if scene is AUDIO_SCENE_PHONE_CALL */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_003, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_003, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2139,7 +2124,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_003, TestSize.Level1) * @tc.number: CheckModemScene_004 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to stopped if scene is AUDIO_SCENE_DEFAULT */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_004, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_004, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2163,7 +2148,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_004, TestSize.Level1) * @tc.number: CheckModemScene_005 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to started if scene is AUDIO_SCENE_PHONE_CALL */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_005, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_005, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2188,7 +2173,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_005, TestSize.Level1) * @tc.number: CheckModemScene_006 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to stopped if scene is AUDIO_SCENE_DEFAULT */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_006, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_006, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2212,7 +2197,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_006, TestSize.Level1) * @tc.number: CheckModemScene_007 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to started if scene is AUDIO_SCENE_PHONE_CALL */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_007, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_007, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2237,7 +2222,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_007, TestSize.Level1) * @tc.number: CheckModemScene_008 * @tc.desc : Test AudioCoreService::CheckModemScene, set streamStatus to stopped if scene is AUDIO_SCENE_DEFAULT */ -HWTEST(AudioCoreServicePrivateTest, CheckModemScene_008, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckModemScene_008, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2262,7 +2247,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckModemScene_008, TestSize.Level1) * @tc.number: UpdateModemRoute_001 * @tc.desc : Test AudioCoreService::UpdateModemRoute */ -HWTEST(AudioCoreServicePrivateTest, UpdateModemRoute_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, UpdateModemRoute_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2284,7 +2269,7 @@ HWTEST(AudioCoreServicePrivateTest, UpdateModemRoute_001, TestSize.Level1) * @tc.number: UpdateModemRoute_002 * @tc.desc : Test AudioCoreService::UpdateModemRoute */ -HWTEST(AudioCoreServicePrivateTest, UpdateModemRoute_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, UpdateModemRoute_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2305,7 +2290,7 @@ HWTEST(AudioCoreServicePrivateTest, UpdateModemRoute_002, TestSize.Level1) * @tc.number: IsStreamSupportLowpower_001 * @tc.desc : Test AudioCoreService::IsStreamSupportLowpower, if playerType is PLAYER_TYPE_SOUND_POOL, return false */ -HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsStreamSupportLowpower_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2324,7 +2309,7 @@ HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_001, TestSize.Level1 * @tc.number: IsStreamSupportLowpower_002 * @tc.desc : Test AudioCoreService::IsStreamSupportLowpower, if playerType is PLAYER_TYPE_OPENSL_ES, return false */ -HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsStreamSupportLowpower_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2343,7 +2328,7 @@ HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_002, TestSize.Level1 * @tc.number: IsStreamSupportLowpower_003 * @tc.desc : Test interface IsStreamSupportLowpower */ -HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_003, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsStreamSupportLowpower_003, TestSize.Level1) { AUDIO_INFO_LOG("AudioCoreServicePrivateTest IsStreamSupportLower start"); auto audioCoreService = std::make_shared(); @@ -2362,7 +2347,7 @@ HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_003, TestSize.Level1 * @tc.number: IsStreamSupportLowpower_004 * @tc.desc : Test interface IsStreamSupportLowpower */ -HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_004, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsStreamSupportLowpower_004, TestSize.Level1) { AUDIO_INFO_LOG("AudioCoreServicePrivateTest IsStreamSupportLower start"); auto audioCoreService = std::make_shared(); @@ -2378,43 +2363,12 @@ HWTEST(AudioCoreServicePrivateTest, IsStreamSupportLowpower_004, TestSize.Level1 EXPECT_EQ(isSupportLowPower, false); } -/** - * @tc.name : Test AudioCoreService. - * @tc.number: AudioCoreServicePrivate_122 - * @tc.desc : Test AudioCoreService::ReConfigOffloadStatus - */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_122, TestSize.Level1) -{ - auto audioCoreService = std::make_shared(); - ASSERT_NE(audioCoreService, nullptr); - std::shared_ptr pipeInfo = std::make_shared(); - ASSERT_NE(pipeInfo, nullptr); - std::string sinkName = "test"; - - pipeInfo->moduleInfo_.name = "test"; - pipeInfo->moduleInfo_.className = "test"; - audioCoreService->ReConfigOffloadStatus(0, pipeInfo, sinkName); - - pipeInfo->moduleInfo_.name = "test"; - pipeInfo->moduleInfo_.className = "remote_offload"; - audioCoreService->ReConfigOffloadStatus(0, pipeInfo, sinkName); - - pipeInfo->moduleInfo_.name = "Offload_Speaker"; - pipeInfo->moduleInfo_.className = "test"; - audioCoreService->ReConfigOffloadStatus(0, pipeInfo, sinkName); - - pipeInfo->moduleInfo_.name = "Offload_Speaker"; - pipeInfo->moduleInfo_.className = "remote_offload"; - audioCoreService->ReConfigOffloadStatus(0, pipeInfo, sinkName); - EXPECT_EQ(audioCoreService->audioOffloadStream_.offloadSessionID_.has_value(), true); -} - /** * @tc.name : Test AudioCoreService. * @tc.number: AudioCoreServicePrivate_123 * @tc.desc : Test AudioCoreService::RemoveUnusedPipe */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_123, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_123, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2434,7 +2388,8 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_123, TestSize.Level1 audioCoreService->pipeManager_->AddAudioPipeInfo(pipe2); audioCoreService->RemoveUnusedPipe(); - EXPECT_EQ(audioCoreService->pipeManager_->GetUnusedPipe().size(), 2); // 2: unused pipe size + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + EXPECT_EQ(audioCoreService->pipeManager_->GetUnusedPipe(deviceType).size(), 2); // 2: unused pipe size } /** @@ -2442,7 +2397,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_123, TestSize.Level1 * @tc.number: LoadSplitModule_001 * @tc.desc : Test AudioCoreService::LoadSplitModule. */ -HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, LoadSplitModule_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2456,7 +2411,7 @@ HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_001, TestSize.Level1) * @tc.number: LoadSplitModule_002 * @tc.desc : Test AudioCoreService::LoadSplitModule. */ -HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, LoadSplitModule_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2472,7 +2427,7 @@ HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_002, TestSize.Level1) * @tc.number: LoadSplitModule_003 * @tc.desc : Test AudioCoreService::LoadSplitModule. */ -HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_003, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, LoadSplitModule_003, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2488,7 +2443,7 @@ HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_003, TestSize.Level1) * @tc.number: LoadSplitModule_004 * @tc.desc : Test AudioCoreService::LoadSplitModule. */ -HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_004, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, LoadSplitModule_004, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2499,13 +2454,12 @@ HWTEST(AudioCoreServicePrivateTest, LoadSplitModule_004, TestSize.Level1) EXPECT_EQ(ret, 0); } - /** * @tc.name : Test AudioCoreService. * @tc.number: AudioCoreServicePrivate_124 * @tc.desc : Test AudioCoreService::OpenNewAudioPortAndRoute() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_124, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_124, TestSize.Level1) { uint32_t sessionIDTest = 100; @@ -2536,7 +2490,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_124, TestSize.Level1 * @tc.number: AudioCoreServicePrivate_125 * @tc.desc : Test AudioCoreService::OpenNewAudioPortAndRoute() */ -HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_125, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AudioCoreServicePrivate_125, TestSize.Level1) { uint32_t sessionIDTest = 0; @@ -2571,7 +2525,7 @@ HWTEST(AudioCoreServicePrivateTest, AudioCoreServicePrivate_125, TestSize.Level1 * @tc.number: IsRingerOrAlarmerDualDevicesRange_001. * @tc.desc : Test IsRingerOrAlarmerDualDevicesRange. */ -HWTEST(AudioCoreServicePrivateTest, IsRingerOrAlarmerDualDevicesRange_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, IsRingerOrAlarmerDualDevicesRange_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2584,7 +2538,7 @@ HWTEST(AudioCoreServicePrivateTest, IsRingerOrAlarmerDualDevicesRange_001, TestS * @tc.number: SwitchActiveHearingAidDevice_001. * @tc.desc : Test SwitchActiveHearingAidDevice. */ -HWTEST(AudioCoreServicePrivateTest, SwitchActiveHearingAidDevice_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, SwitchActiveHearingAidDevice_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2617,7 +2571,7 @@ HWTEST(AudioCoreServicePrivateTest, SwitchActiveHearingAidDevice_001, TestSize.L * @tc.number: ResetNearlinkDeviceState_001. * @tc.desc : Test ResetNearlinkDeviceState. */ -HWTEST(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2633,6 +2587,8 @@ HWTEST(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_001, TestSize.Level deviceDesc2->deviceType_ = DEVICE_TYPE_NEARLINK; deviceDesc1->macAddress_ = mac1; deviceDesc2->macAddress_ = mac2; + deviceDesc1->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + deviceDesc2->deviceRole_ = DeviceRole::OUTPUT_DEVICE; audioCoreService->audioActiveDevice_.SetCurrentOutputDevice(*deviceDesc1); @@ -2658,7 +2614,7 @@ HWTEST(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_001, TestSize.Level * @tc.number: ResetNearlinkDeviceState_002. * @tc.desc : Test ResetNearlinkDeviceState. */ -HWTEST(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2674,6 +2630,8 @@ HWTEST(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_002, TestSize.Level deviceDesc2->deviceType_ = DEVICE_TYPE_NEARLINK_IN; deviceDesc1->macAddress_ = mac1; deviceDesc2->macAddress_ = mac2; + deviceDesc1->deviceRole_ = DeviceRole::INPUT_DEVICE; + deviceDesc2->deviceRole_ = DeviceRole::INPUT_DEVICE; audioCoreService->audioActiveDevice_.SetCurrentInputDevice(*deviceDesc1); @@ -2698,7 +2656,7 @@ HWTEST(AudioCoreServicePrivateTest, ResetNearlinkDeviceState_002, TestSize.Level * @tc.number: CaptureConcurrentCheck_001 * @tc.desc : Test AudioCoreService::CaptureConcurrentCheck() */ -HWTEST(AudioCoreServicePrivateTest, CaptureConcurrentCheck_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CaptureConcurrentCheck_001, TestSize.Level1) { AUDIO_INFO_LOG("AudioCoreServicePrivateTest CaptureConcurrentCheck_001 start"); auto audioCoreService = std::make_shared(); @@ -2736,7 +2694,7 @@ HWTEST(AudioCoreServicePrivateTest, CaptureConcurrentCheck_001, TestSize.Level1) * @tc.number: CaptureConcurrentCheck_002 * @tc.desc : Test AudioCoreService::CaptureConcurrentCheck() */ -HWTEST(AudioCoreServicePrivateTest, CaptureConcurrentCheck_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CaptureConcurrentCheck_002, TestSize.Level1) { AUDIO_INFO_LOG("AudioCoreServicePrivateTest CaptureConcurrentCheck_002 start"); auto audioCoreService = std::make_shared(); @@ -2764,7 +2722,7 @@ HWTEST(AudioCoreServicePrivateTest, CaptureConcurrentCheck_002, TestSize.Level1) * @tc.number: ActivateInputDevice_001 * @tc.desc : Test AudioCoreService::ActivateInputDevice() */ -HWTEST(AudioCoreServicePrivateTest, ActivateInputDevice_001, TestSize.Level4) +HWTEST_F(AudioCoreServicePrivateTest, ActivateInputDevice_001, TestSize.Level4) { AUDIO_INFO_LOG("AudioCoreServicePrivateTest ActivateInputDevice_001 start"); auto audioCoreService = std::make_shared(); @@ -2789,7 +2747,7 @@ HWTEST(AudioCoreServicePrivateTest, ActivateInputDevice_001, TestSize.Level4) * @tc.number: ActivateInputDevice_002 * @tc.desc : Test AudioCoreService::ActivateInputDevice() */ -HWTEST(AudioCoreServicePrivateTest, ActivateInputDevice_002, TestSize.Level4) +HWTEST_F(AudioCoreServicePrivateTest, ActivateInputDevice_002, TestSize.Level4) { AUDIO_INFO_LOG("AudioCoreServicePrivateTest ActivateInputDevice_002 start"); auto audioCoreService = std::make_shared(); @@ -2814,7 +2772,7 @@ HWTEST(AudioCoreServicePrivateTest, ActivateInputDevice_002, TestSize.Level4) * @tc.number: CheckAndSleepBeforeRingDualDeviceSet_001 * @tc.desc : Test AudioCoreService::CheckAndSleepBeforeRingDualDeviceSet() */ -HWTEST(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2868,7 +2826,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_001, Te * @tc.number: CheckAndSleepBeforeRingDualDeviceSet_002 * @tc.desc : Test AudioCoreService::CheckAndSleepBeforeRingDualDeviceSet() */ -HWTEST(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2921,7 +2879,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_002, Te * @tc.number: CheckAndSleepBeforeRingDualDeviceSet_003 * @tc.desc : Test AudioCoreService::CheckAndSleepBeforeRingDualDeviceSet() */ -HWTEST(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_003, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_003, TestSize.Level1) { auto audioCoreService = std::make_shared(); ASSERT_NE(audioCoreService, nullptr); @@ -2976,10 +2934,10 @@ HWTEST(AudioCoreServicePrivateTest, CheckAndSleepBeforeRingDualDeviceSet_003, Te * @tc.number: SleepForSwitchDevice_001 * @tc.desc : Test AudioCoreService::SleepForSwitchDevice() */ -HWTEST(AudioCoreServicePrivateTest, SleepForSwitchDevice_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, SleepForSwitchDevice_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); - EXPECT_NE(audioCoreService, nullptr); + ASSERT_NE(audioCoreService, nullptr); std::shared_ptr streamDesc = std::make_shared(); std::shared_ptr oldDesc = std::make_shared( @@ -3006,10 +2964,10 @@ HWTEST(AudioCoreServicePrivateTest, SleepForSwitchDevice_001, TestSize.Level1) * @tc.number: SleepForSwitchDevice_002 * @tc.desc : Test AudioCoreService::SleepForSwitchDevice() */ -HWTEST(AudioCoreServicePrivateTest, SleepForSwitchDevice_002, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, SleepForSwitchDevice_002, TestSize.Level1) { auto audioCoreService = std::make_shared(); - EXPECT_NE(audioCoreService, nullptr); + ASSERT_NE(audioCoreService, nullptr); std::shared_ptr streamDesc = std::make_shared(); std::shared_ptr oldDesc = std::make_shared( @@ -3038,10 +2996,10 @@ HWTEST(AudioCoreServicePrivateTest, SleepForSwitchDevice_002, TestSize.Level1) * @tc.number: SleepForSwitchDevice_003 * @tc.desc : Test AudioCoreService::SleepForSwitchDevice() */ -HWTEST(AudioCoreServicePrivateTest, SleepForSwitchDevice_003, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, SleepForSwitchDevice_003, TestSize.Level1) { auto audioCoreService = std::make_shared(); - EXPECT_NE(audioCoreService, nullptr); + ASSERT_NE(audioCoreService, nullptr); std::shared_ptr streamDesc = std::make_shared(); std::shared_ptr oldDesc = std::make_shared( @@ -3073,12 +3031,12 @@ HWTEST(AudioCoreServicePrivateTest, SleepForSwitchDevice_003, TestSize.Level1) * @tc.number: AddSessionId_001 * @tc.desc : Test AudioCoreService::AddSessionId() */ -HWTEST(AudioCoreServicePrivateTest, AddSessionId_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, AddSessionId_001, TestSize.Level3) { auto audioCoreService = std::make_shared(); uint32_t sessionId = 1; audioCoreService->AddSessionId(sessionId); - ASSERT_EQ(audioCoreService->sessionIdMap_.count(sessionId), 0); + EXPECT_EQ(1, audioCoreService->sessionIdMap_.count(sessionId)); audioCoreService->DeleteSessionId(sessionId); } @@ -3087,7 +3045,7 @@ HWTEST(AudioCoreServicePrivateTest, AddSessionId_001, TestSize.Level1) * @tc.number: CheckAndUpdateHearingAidCall_001 * @tc.desc : Test AudioCoreService::CheckAndUpdateHearingAidCall */ -HWTEST(AudioCoreServicePrivateTest, CheckAndUpdateHearingAidCall_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateHearingAidCall_001, TestSize.Level1) { auto audioCoreService = std::make_shared(); audioCoreService->audioSceneManager_.audioScene_ = AUDIO_SCENE_PHONE_CALL; @@ -3103,7 +3061,7 @@ HWTEST(AudioCoreServicePrivateTest, CheckAndUpdateHearingAidCall_001, TestSize.L * @tc.number: ActivateOutputDevice_001 * @tc.desc : Test AudioCoreService::ActivateOutputDevice */ -HWTEST(AudioCoreServicePrivateTest, ActivateOutputDevice_001, TestSize.Level1) +HWTEST_F(AudioCoreServicePrivateTest, ActivateOutputDevice_001, TestSize.Level1) { std::shared_ptr newDeviceDesc = std::make_shared(); newDeviceDesc->deviceType_ = DEVICE_TYPE_HEARING_AID; @@ -3113,5 +3071,108 @@ HWTEST(AudioCoreServicePrivateTest, ActivateOutputDevice_001, TestSize.Level1) int32_t ret = audioCoreService->ActivateOutputDevice(streamDesc); ASSERT_EQ(ret, SUCCESS); } + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_001 + * @tc.number : CheckAndUpdateOffloadEnableForStream_001 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload new case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_001, TestSize.Level3) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_NEW, stream); + EXPECT_EQ(TEST_STREAM_1_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_002 + * @tc.number : CheckAndUpdateOffloadEnableForStream_002 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload move in case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_002, TestSize.Level3) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_IN, stream); + EXPECT_EQ(TEST_STREAM_1_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_003 + * @tc.number : CheckAndUpdateOffloadEnableForStream_003 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload move in case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_003, TestSize.Level4) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_2_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_NORMAL); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_IN, stream); + EXPECT_NE(TEST_STREAM_2_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_004 + * @tc.number : CheckAndUpdateOffloadEnableForStream_004 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload move out case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_004, TestSize.Level3) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_NORMAL); + stream->SetOldRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_OUT, stream); + EXPECT_NE(TEST_STREAM_1_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_005 + * @tc.number : CheckAndUpdateOffloadEnableForStream_005 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload move out case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_005, TestSize.Level3) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_NORMAL); + stream->SetOldRoute(AUDIO_OUTPUT_FLAG_NORMAL); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_OUT, stream); + EXPECT_NE(TEST_STREAM_1_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_006 + * @tc.number : CheckAndUpdateOffloadEnableForStream_006 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload move out case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_006, TestSize.Level3) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + stream->SetOldRoute(AUDIO_OUTPUT_FLAG_NORMAL); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_OUT, stream); + EXPECT_NE(TEST_STREAM_1_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + +/** + * @tc.name : AudioCoreServicePrivateTest_CheckAndUpdateOffloadEnableForStream_007 + * @tc.number : CheckAndUpdateOffloadEnableForStream_007 + * @tc.desc : Test CheckAndUpdateOffloadEnableForStream() for offload move out case + */ +HWTEST_F(AudioCoreServicePrivateTest, CheckAndUpdateOffloadEnableForStream_007, TestSize.Level3) +{ + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + stream->SetRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + stream->SetOldRoute(AUDIO_OUTPUT_FLAG_LOWPOWER); + testCoreService_->CheckAndUpdateOffloadEnableForStream(OFFLOAD_MOVE_OUT, stream); + EXPECT_NE(TEST_STREAM_1_SESSION_ID, testCoreService_->audioOffloadStream_.GetOffloadSessionId(OFFLOAD_IN_PRIMARY)); +} + } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_core_service_unit_test/src/audio_core_service_unit_test.cpp b/services/audio_policy/test/unittest/audio_core_service_unit_test/src/audio_core_service_unit_test.cpp index 13715214ba6748fed0b2abf9755ca2c1cc20cf0f..ea13c843c4962a83a85f9c48bdfbcfcb36714798 100644 --- a/services/audio_policy/test/unittest/audio_core_service_unit_test/src/audio_core_service_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_core_service_unit_test/src/audio_core_service_unit_test.cpp @@ -817,6 +817,34 @@ HWTEST_F(AudioCoreServiceUnitTest, IsStreamSupportMultiChannel_002, TestSize.Lev EXPECT_EQ(GetServerPtr()->coreService_->IsStreamSupportMultiChannel(streamDesc), false); } +/** + * @tc.name : Test AudioCoreServiceUnit + * @tc.number : UpdatePlaybackStreamFlag_001 + * @tc.desc : Test UpdatePlaybackStreamFlag interface - when streamDesc is null, return flag normal. + */ +HWTEST_F(AudioCoreServiceUnitTest, UpdatePlaybackStreamFlag_001, TestSize.Level1) +{ + ASSERT_NE(nullptr, GetServerPtr()); + std::shared_ptr streamDesc = std::make_shared(); + streamDesc->rendererInfo_.rendererFlags = AUDIO_FLAG_FORCED_NORMAL; + + bool isCreateProcess = true; + GetServerPtr()->coreService_->UpdatePlaybackStreamFlag(streamDesc, isCreateProcess); + EXPECT_EQ(streamDesc->audioFlag_, AUDIO_OUTPUT_FLAG_NORMAL); + + streamDesc->rendererInfo_.forceToNormal = true; + GetServerPtr()->coreService_->UpdatePlaybackStreamFlag(streamDesc, isCreateProcess); + EXPECT_EQ(streamDesc->audioFlag_, AUDIO_OUTPUT_FLAG_NORMAL); + + isCreateProcess = false; + GetServerPtr()->coreService_->UpdatePlaybackStreamFlag(streamDesc, isCreateProcess); + EXPECT_EQ(streamDesc->audioFlag_, AUDIO_OUTPUT_FLAG_NORMAL); + + streamDesc->rendererInfo_.forceToNormal = false; + GetServerPtr()->coreService_->UpdatePlaybackStreamFlag(streamDesc, isCreateProcess); + EXPECT_EQ(streamDesc->audioFlag_, AUDIO_OUTPUT_FLAG_NORMAL); +} + /** * @tc.name : Test AudioCoreServiceUnit * @tc.number : SetFlagForSpecialStream_001 @@ -1305,5 +1333,28 @@ HWTEST_F(AudioCoreServiceUnitTest, SetAudioScene_006, TestSize.Level1) audioCoreService->audioVolumeManager_.SetAppRingMuted(appUid, false); audioVolume->streamVolume_.clear(); } + +/** +* @tc.name : Test AudioCoreService +* @tc.number: SetFlagForMmapStream_001 +* @tc.desc : Test SetFlagForMmapStream() when device type is DEVICE_TYPE_BLUETOOTH_A2DP +*/ +HWTEST_F(AudioCoreServiceUnitTest, SetFlagForMmapStream_001, TestSize.Level4) +{ + AUDIO_INFO_LOG("AudioCoreServiceUnitTest CreateRenderClient_001 start"); + + ASSERT_NE(nullptr, GetServerPtr()); + auto coreService_ = GetServerPtr()->coreService_; + std::shared_ptr streamDesc = std::make_shared(); + ASSERT_NE(nullptr, streamDesc); + std::shared_ptr deviceDesc = std::make_shared(); + ASSERT_NE(nullptr, deviceDesc); + + deviceDesc->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + streamDesc->newDeviceDescs_.push_back(deviceDesc); + + auto ret = coreService_->SetFlagForMmapStream(streamDesc); + EXPECT_EQ(AUDIO_OUTPUT_FLAG_FAST, ret); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_device_common_unit_test/src/audio_device_common_unit_test.cpp b/services/audio_policy/test/unittest/audio_device_common_unit_test/src/audio_device_common_unit_test.cpp index f77cbac54fd42471e233648fdb0dbb0efeff99e2..b6fc21db03aeb5ca478deaf57b8c8f11b9b067f9 100644 --- a/services/audio_policy/test/unittest/audio_device_common_unit_test/src/audio_device_common_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_device_common_unit_test/src/audio_device_common_unit_test.cpp @@ -1172,116 +1172,6 @@ HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_070, TestSize.Level1) EXPECT_EQ(true, ret); } -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_072 -* @tc.desc : Test CheckAndNotifyUserSelectedDevice interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_072, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr desc = std::make_shared(); - audioDeviceCommon.CheckAndNotifyUserSelectedDevice(desc); - bool ret = audioDeviceCommon.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(false, ret); -} - -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_073 -* @tc.desc : Test ResetOffloadAndMchMode interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_073, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> outputDevices; - std::shared_ptr outputDevice = std::make_shared(); - outputDevice->networkId_ = ""; - outputDevices.push_back(std::move(outputDevice)); - audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices); -} - -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_074 -* @tc.desc : Test ResetOffloadAndMchMode interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_074, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> outputDevices; - std::shared_ptr outputDevice = std::make_shared(); - outputDevice->networkId_ = "LocalDevice"; - outputDevice->deviceType_ = DEVICE_TYPE_REMOTE_CAST; - outputDevices.push_back(std::move(outputDevice)); - audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices); -} - -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_075 -* @tc.desc : Test ResetOffloadAndMchMode interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_075, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> outputDevices; - std::shared_ptr outputDevice = std::make_shared(); - outputDevice->networkId_ = "LocalDevice"; - outputDevice->deviceType_ = DEVICE_TYPE_DP; - outputDevices.push_back(std::move(outputDevice)); - audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices); -} - -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_076 -* @tc.desc : Test JudgeIfLoadMchModule interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_076, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - audioDeviceCommon.JudgeIfLoadMchModule(); - - AudioIOHandle moduleId = 0; - std::string moduleName = "MCH_Speaker"; - audioDeviceCommon.audioIOHandleMap_.AddIOHandleInfo(moduleName, moduleId); - audioDeviceCommon.JudgeIfLoadMchModule(); -} - -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_077 -* @tc.desc : Test FetchStreamForA2dpMchStream interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_077, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> descs; - std::shared_ptr desc = std::make_shared(); - descs.push_back(std::move(desc)); - audioDeviceCommon.FetchStreamForA2dpMchStream(rendererChangeInfo, descs); -} - -/** -* @tc.name : Test AudioDeviceCommon. -* @tc.number: AudioDeviceCommon_078 -* @tc.desc : Test FetchStreamForSpkMchStream interface. -*/ -HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_078, TestSize.Level1) -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> descs; - std::shared_ptr desc = std::make_shared(); - descs.push_back(std::move(desc)); - audioDeviceCommon.FetchStreamForSpkMchStream(rendererChangeInfo, descs); -} - /** * @tc.name : Test AudioDeviceCommon. * @tc.number: AudioDeviceCommon_079 diff --git a/services/audio_policy/test/unittest/audio_device_status_unit_test/src/audio_device_status_unit_test.cpp b/services/audio_policy/test/unittest/audio_device_status_unit_test/src/audio_device_status_unit_test.cpp index 115b619d44cafb67fbacd2a7f6d93a2ade7c19e6..756be3a4c7f49779977ee7b5047b69ca3a7ed803 100644 --- a/services/audio_policy/test/unittest/audio_device_status_unit_test/src/audio_device_status_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_device_status_unit_test/src/audio_device_status_unit_test.cpp @@ -1465,5 +1465,120 @@ HWTEST_F(AudioDeviceStatusUnitTest, AudioDeviceStatus_069, TestSize.Level1) int32_t result = audioDeviceStatus.HandleLocalDeviceDisconnected(updatedDesc); EXPECT_EQ(result, SUCCESS); } + +/** +* @tc.name : Test AudioDeviceStatus. +* @tc.number: WriteOutputDeviceChangedSysEvents_001 +* @tc.desc : Test WriteOutputDeviceChangedSysEvents interface. +*/ +HWTEST_F(AudioDeviceStatusUnitTest, WriteOutputDeviceChangedSysEvents_001, TestSize.Level1) +{ + std::shared_ptr deviceDescriptor = std::make_shared(); + SinkInput sinkInput; + deviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + deviceDescriptor->macAddress_ = "00:11:22:33:44:55"; + deviceDescriptor->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + deviceDescriptor->networkId_ = "123456"; + deviceDescriptor->deviceName_ = "usb_headset"; + deviceDescriptor->deviceCategory_ = BT_UNWEAR_HEADPHONE; + sinkInput.streamId = 1; + sinkInput.streamType = STREAM_RING; + AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance(); + + audioDeviceStatus.WriteOutputDeviceChangedSysEvents(deviceDescriptor, sinkInput); + EXPECT_EQ(deviceDescriptor->deviceId_, 0); +} + +/** +* @tc.name : Test AudioDeviceStatus. +* @tc.number: WriteInputDeviceChangedSysEvents_001 +* @tc.desc : Test WriteInputDeviceChangedSysEvents interface. +*/ +HWTEST_F(AudioDeviceStatusUnitTest, WriteInputDeviceChangedSysEvents_001, TestSize.Level1) +{ + std::shared_ptr deviceDescriptor = std::make_shared(); + SourceOutput sourceOutput; + deviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + deviceDescriptor->macAddress_ = "00:11:22:33:44:55"; + deviceDescriptor->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + deviceDescriptor->networkId_ = "123456"; + deviceDescriptor->deviceName_ = "usb_headset"; + deviceDescriptor->deviceCategory_ = BT_UNWEAR_HEADPHONE; + sourceOutput.streamId = 1; + sourceOutput.streamType = STREAM_RING; + AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance(); + + audioDeviceStatus.WriteInputDeviceChangedSysEvents(deviceDescriptor, sourceOutput); + EXPECT_EQ(deviceDescriptor->deviceId_, 0); +} + +/** +* @tc.name : Test AudioDeviceStatus. +* @tc.number: RemoveDeviceFromGlobalOnly_001 +* @tc.desc : Test RemoveDeviceFromGlobalOnly interface. +*/ +HWTEST_F(AudioDeviceStatusUnitTest, RemoveDeviceFromGlobalOnly_001, TestSize.Level1) +{ + std::shared_ptr deviceDescriptor = std::make_shared(); + deviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + deviceDescriptor->macAddress_ = "00:11:22:33:44:55"; + deviceDescriptor->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + deviceDescriptor->networkId_ = "123456"; + deviceDescriptor->deviceName_ = "usb_headset"; + deviceDescriptor->deviceCategory_ = BT_UNWEAR_HEADPHONE; + AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance(); + + audioDeviceStatus.RemoveDeviceFromGlobalOnly(deviceDescriptor); + EXPECT_EQ(deviceDescriptor->deviceId_, 0); +} + +/** +* @tc.name : Test AudioDeviceStatus. +* @tc.number: AddDeviceBackToGlobalOnly_001 +* @tc.desc : Test AddDeviceBackToGlobalOnly interface. +*/ +HWTEST_F(AudioDeviceStatusUnitTest, AddDeviceBackToGlobalOnly_001, TestSize.Level1) +{ + std::shared_ptr deviceDescriptor = std::make_shared(); + deviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + deviceDescriptor->macAddress_ = "00:11:22:33:44:55"; + deviceDescriptor->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + deviceDescriptor->networkId_ = "123456"; + deviceDescriptor->deviceName_ = "usb_headset"; + deviceDescriptor->deviceCategory_ = BT_UNWEAR_HEADPHONE; + AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance(); + + audioDeviceStatus.AddDeviceBackToGlobalOnly(deviceDescriptor); + EXPECT_EQ(deviceDescriptor->deviceId_, 0); +} + +/** +* @tc.name : Test AudioDeviceStatus. +* @tc.number: GetDmDeviceType_001 +* @tc.desc : Test GetDmDeviceType interface. +*/ +HWTEST_F(AudioDeviceStatusUnitTest, GetDmDeviceType_001, TestSize.Level1) +{ + AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance(); + + uint16_t ret = audioDeviceStatus.GetDmDeviceType(); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioDeviceStatus. +* @tc.number: GetPaIndexByPortName_001 +* @tc.desc : Test GetPaIndexByPortName interface. +*/ +HWTEST_F(AudioDeviceStatusUnitTest, GetPaIndexByPortName_001, TestSize.Level1) +{ + string portName = PRIMARY_SPEAKER; + AudioIOHandle moduleId = 2; + AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance(); + + audioDeviceStatus.audioIOHandleMap_.AddIOHandleInfo(portName, moduleId); + uint32_t ret = audioDeviceStatus.GetPaIndexByPortName(portName); + EXPECT_NE(ret, moduleId); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp index 2990179407c131e7ae3b07d0573fbf5e0109a101..0d9a80ed9b1915cb7736fa04c6dfeb8521930388 100644 --- a/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp @@ -21,6 +21,9 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { + +const static uint64_t TEST_SESSION_ID = 1; + void AudioEcManagerUnitTest::SetUpTestCase(void) {} void AudioEcManagerUnitTest::TearDownTestCase(void) {} void AudioEcManagerUnitTest::SetUp(void) {} @@ -646,5 +649,208 @@ HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_027, TestSize.Level4) ecManager.GetTargetSourceTypeAndMatchingFlag(source, targetSource, useMatchingPropInfo); EXPECT_EQ(targetSource, SOURCE_TYPE_LIVE); } + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_028 +* @tc.desc : Test UpdateStreamCommonInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_028, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + bool originIsEcFeatureEnable = ecManager.isEcFeatureEnable_; + ecManager.isEcFeatureEnable_ = false; + AudioModuleInfo moduleInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + ecManager.UpdateStreamCommonInfo(moduleInfo, targetInfo, sourceType); + EXPECT_EQ(moduleInfo.sourceType, "0"); + + ecManager.isEcFeatureEnable_ = true; + ecManager.UpdateStreamCommonInfo(moduleInfo, targetInfo, sourceType); + EXPECT_EQ(moduleInfo.sourceType, "0"); + + ecManager.isEcFeatureEnable_ = originIsEcFeatureEnable; +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_029 +* @tc.desc : Test UpdateEnhanceEffectState interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_029, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + ecManager.UpdateEnhanceEffectState(sourceType); + EXPECT_EQ(ecManager.isMicRefRecordOn_, false); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_030 +* @tc.desc : Test UpdateStreamMicRefInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_030, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + EXPECT_NO_THROW( + ecManager.UpdateStreamMicRefInfo(moduleInfo, sourceType); + ); + + sourceType = SourceType::SOURCE_TYPE_VOICE_COMMUNICATION; + EXPECT_NO_THROW( + ecManager.UpdateStreamMicRefInfo(moduleInfo, sourceType); + ); + + sourceType = SOURCE_TYPE_INVALID; + EXPECT_NO_THROW( + ecManager.UpdateStreamMicRefInfo(moduleInfo, sourceType); + ); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_031 +* @tc.desc : Test ReloadNormalSource interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_031, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SessionInfo sessionInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType targetSource = SourceType::SOURCE_TYPE_MIC; + int32_t ret = ecManager.ReloadNormalSource(sessionInfo, targetInfo, targetSource); + EXPECT_EQ(ret, ERROR); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_032 +* @tc.desc : Test GetOpenedNormalSourceSessionId interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_032, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + uint64_t ret = ecManager.GetOpenedNormalSourceSessionId(); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_033 +* @tc.desc : Test SetOpenedNormalSourceSessionId interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_033, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + uint64_t originSessionId = ecManager.sessionIdUsedToOpenSource_; + uint64_t sessionId = TEST_SESSION_ID; + ecManager.SetOpenedNormalSourceSessionId(sessionId); + EXPECT_EQ(ecManager.sessionIdUsedToOpenSource_, sessionId); + + ecManager.sessionIdUsedToOpenSource_ = originSessionId; +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_034 +* @tc.desc : Test PrepareNormalSource interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_034, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + std::shared_ptr streamDesc = std::make_shared(); + EXPECT_NO_THROW( + ecManager.PrepareNormalSource(moduleInfo, streamDesc); + ); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_035 +* @tc.desc : Test SetOpenedNormalSource interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_035, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SourceType origin = ecManager.normalSourceOpened_; + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + ecManager.SetOpenedNormalSource(sourceType); + EXPECT_EQ(sourceType, ecManager.normalSourceOpened_); + + ecManager.normalSourceOpened_ = origin; +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_036 +* @tc.desc : Test SetPrimaryMicModuleInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_036, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + moduleInfo.name = "test"; + ecManager.SetPrimaryMicModuleInfo(moduleInfo); + EXPECT_EQ(ecManager.primaryMicModuleInfo_.name, moduleInfo.name); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_037 +* @tc.desc : Test SetDpSinkModuleInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_037, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + moduleInfo.className = "AudioEcManagerUnitTest"; + ecManager.SetDpSinkModuleInfo(moduleInfo); + EXPECT_EQ(ecManager.dpSinkModuleInfo_.className, moduleInfo.className); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_038 +* @tc.desc : Test FetchTargetInfoForSessionAdd interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_038, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SessionInfo sessionInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType targetSourceType = SourceType::SOURCE_TYPE_MIC; + int32_t ret = ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); + EXPECT_EQ(ret, ERROR); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_039 +* @tc.desc : Test FetchTargetInfoForSessionAdd interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_039, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SessionInfo sessionInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType targetSourceType = SourceType::SOURCE_TYPE_MIC; + bool originEcFeatureEnable_ = ecManager.isEcFeatureEnable_; + std::string originMicSpeaker = ecManager.primaryMicModuleInfo_.OpenMicSpeaker; + + ecManager.isEcFeatureEnable_ = false; + ecManager.primaryMicModuleInfo_.OpenMicSpeaker = "0"; + int32_t ret = ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); + EXPECT_EQ(ret, ERROR); + + ecManager.isEcFeatureEnable_ = true; + ecManager.primaryMicModuleInfo_.OpenMicSpeaker = "1"; + ret = ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); + EXPECT_EQ(ret, ERROR); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_effect_service_test/src/audio_effect_service_test.cpp b/services/audio_policy/test/unittest/audio_effect_service_test/src/audio_effect_service_test.cpp index cc6a9a06a7648ec38aa430ed3b43b2df7b674ab5..6573c0f3bda4d46ec9be39489b5d9d1bb4d9931c 100644 --- a/services/audio_policy/test/unittest/audio_effect_service_test/src/audio_effect_service_test.cpp +++ b/services/audio_policy/test/unittest/audio_effect_service_test/src/audio_effect_service_test.cpp @@ -695,5 +695,148 @@ HWTEST(AudioEffectServiceTest, audioEffectService_034, TestSize.Level1) mergedSet, device2PropertySet); EXPECT_EQ(result, AUDIO_OK); } + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: GetOriginalEffectConfig. +* @tc.desc : Test GetOriginalEffectConfig. +*/ +HWTEST(AudioEffectServiceTest, GetOriginalEffectConfig, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + audioEffectService_->oriEffectConfig_.version = "v1.1.1"; + OriginalEffectConfig oriEffectConfig; + std::string configVersion = "v1.1.1"; + audioEffectService_->GetOriginalEffectConfig(oriEffectConfig); + EXPECT_EQ(oriEffectConfig.version, configVersion); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: GetAvailableEffects. +* @tc.desc : Test GetAvailableEffects. +*/ +HWTEST(AudioEffectServiceTest, GetAvailableEffects, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + Effect effect = {}; + audioEffectService_->availableEffects_.emplace_back(effect); + std::vector availableEffects; + audioEffectService_->GetAvailableEffects(availableEffects); + EXPECT_NE(availableEffects.size(), 0); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: UpdateAvailableEffects. +* @tc.desc : Test UpdateAvailableEffects. +*/ +HWTEST(AudioEffectServiceTest, UpdateAvailableEffects, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + std::vector newAvailableEffects; + audioEffectService_->UpdateAvailableEffects(newAvailableEffects); + EXPECT_EQ(audioEffectService_->availableEffects_.size(), 0); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: GetSupportedEffectConfig. +* @tc.desc : Test GetSupportedEffectConfig. +*/ +HWTEST(AudioEffectServiceTest, GetSupportedEffectConfig, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + SupportedEffectConfig supportedEffectConfig; + audioEffectService_->GetSupportedEffectConfig(supportedEffectConfig); + EXPECT_EQ(supportedEffectConfig.effectChains.size(), 0); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: SetMasterSinkAvailable. +* @tc.desc : Test SetMasterSinkAvailable. +*/ +HWTEST(AudioEffectServiceTest, SetMasterSinkAvailable, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + audioEffectService_->SetMasterSinkAvailable(); + EXPECT_TRUE(audioEffectService_->isMasterSinkAvailable_); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: SetEffectChainManagerAvailable. +* @tc.desc : Test SetEffectChainManagerAvailable. +*/ +HWTEST(AudioEffectServiceTest, SetEffectChainManagerAvailable, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + audioEffectService_->SetEffectChainManagerAvailable(); + EXPECT_TRUE(audioEffectService_->isEffectChainManagerAvailable_); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: CanLoadEffectSinks. +* @tc.desc : Test CanLoadEffectSinks. +*/ +HWTEST(AudioEffectServiceTest, CanLoadEffectSinks, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + audioEffectService_->SetMasterSinkAvailable(); + audioEffectService_->SetEffectChainManagerAvailable(); + bool ret = audioEffectService_->CanLoadEffectSinks(); + EXPECT_TRUE(ret); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: QueryEffectManagerSceneMode. +* @tc.desc : Test QueryEffectManagerSceneMode. +*/ +HWTEST(AudioEffectServiceTest, QueryEffectManagerSceneMode, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + SupportedEffectConfig supportedEffectConfig; + int32_t ret = audioEffectService_->QueryEffectManagerSceneMode(supportedEffectConfig); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: AddSupportedAudioEffectPropertyByDevice. +* @tc.desc : Test AddSupportedAudioEffectPropertyByDevice. +*/ +HWTEST(AudioEffectServiceTest, AddSupportedAudioEffectPropertyByDevice, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + std::set> mergedSet; + std::unordered_map>> device2PropertySet; + std::set> device2Property; + device2PropertySet.insert({"DEVICE_TYPE_DEFAULT", device2Property}); + audioEffectService_->device2EffectPropertySet_ = device2PropertySet; + int32_t result = audioEffectService_->AddSupportedAudioEffectPropertyByDevice(DeviceType::DEVICE_TYPE_NONE, + mergedSet); + EXPECT_EQ(result, AUDIO_OK); +} + +/** +* @tc.name : Test AudioEffectService. +* @tc.number: AddSupportedAudioEnhancePropertyByDevice. +* @tc.desc : Test AddSupportedAudioEnhancePropertyByDevice. +*/ +HWTEST(AudioEffectServiceTest, AddSupportedAudioEnhancePropertyByDevice, TestSize.Level4) +{ + auto audioEffectService_ = std::make_shared(); + std::set> mergedSet; + std::unordered_map>> device2PropertySet; + std::set> device2Property; + device2PropertySet.insert({"DEVICE_TYPE_DEFAULT", device2Property}); + audioEffectService_->device2EnhancePropertySet_ = device2PropertySet; + int32_t result = audioEffectService_->AddSupportedAudioEnhancePropertyByDevice(DeviceType::DEVICE_TYPE_NONE, + mergedSet); + EXPECT_EQ(result, AUDIO_OK); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp index 44345de6be51c4203e829a8289ecb5f49fb8c27d..a0c34118260ab96ee983923f492fbc19c143f1fc 100644 --- a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp @@ -186,6 +186,12 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_004, TestSize. int32_t fakePid = 123; auto ret = audioInterruptService->IsSessionNeedToFetchOutputDevice(fakePid); EXPECT_EQ(false, ret); + + audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService(); + ret = audioInterruptService->IsSessionNeedToFetchOutputDevice(fakePid); + EXPECT_EQ(false, ret); + + audioInterruptService->sessionService_ = nullptr; ret = audioInterruptService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA); EXPECT_EQ(true, ret); @@ -1340,5 +1346,405 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_GetAudioSessio EXPECT_EQ(ret.at(0), 1000); } +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_046 +* @tc.desc : Test CanMixForSession +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_046, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + AudioInterrupt incomingInterrupt, activeInterrupt; + AudioFocusEntry focusEntry; + focusEntry.isReject = false; + incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID; + auto ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC; + ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + focusEntry.isReject = true; + incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID; + ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + focusEntry.isReject = false; + incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC; + activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL; + ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID; + incomingInterrupt.audioFocusType.streamType = STREAM_INTERNAL_FORCE_STOP; + ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + incomingInterrupt.audioFocusType.streamType = STREAM_GAME; + activeInterrupt.audioFocusType.streamType == STREAM_INTERNAL_FORCE_STOP; + ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + incomingInterrupt.audioFocusType.streamType = STREAM_INTERNAL_FORCE_STOP; + ret = audioInterruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_047 +* @tc.desc : Test CanMixForIncomingSession +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_047, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + AudioInterrupt incomingInterrupt, activeInterrupt; + AudioFocusEntry focusEntry; + incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT; + auto ret = audioInterruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(true, ret); + incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS; + ret = audioInterruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(true, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_048 +* @tc.desc : Test CanMixForActiveSession +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_048, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + int32_t pid = 123; + AudioInterrupt incomingInterrupt, activeInterrupt; + AudioFocusEntry focusEntry; + activeInterrupt.pid = pid; + audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService(); + audioInterruptService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA); + focusEntry.actionOn = CURRENT; + focusEntry.hintType = INTERRUPT_HINT_PAUSE; + auto ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(false, ret); + + audioInterruptService->sessionService_ = nullptr; + activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT; + ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(true, ret); + activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS; + ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry); + EXPECT_EQ(true, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_049 +* @tc.desc : Test SetAudioManagerInterruptCallback_001 +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_049, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + auto object = new RemoteObjectTestStub(); + auto ret = audioInterruptService->SetAudioManagerInterruptCallback(object); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_050 +* @tc.desc : Test SetAudioManagerInterruptCallback_002 +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_050, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + auto object = new RemoteObjectTestStub(); + audioInterruptService->handler_ = make_shared(); + auto ret = audioInterruptService->SetAudioManagerInterruptCallback(object); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_051 +* @tc.desc : Test SetAudioInterruptCallback +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_051, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + int32_t zoneId = 123; + int32_t streamId = 123; + int32_t uid = 123; + auto object = new RemoteObjectTestStub(); + auto ret = audioInterruptService->SetAudioInterruptCallback(zoneId, streamId, object, uid); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_052 +* @tc.desc : Test UnsetAudioInterruptCallback +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_052, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + int32_t zoneId = 123; + int32_t streamId = 123; + auto ret = audioInterruptService->UnsetAudioInterruptCallback(zoneId, streamId); + EXPECT_EQ(ERR_INVALID_PARAM, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_053 +* @tc.desc : Test GetSessionInfoInFocus +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_053, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + AudioInterrupt audioInterrupt; + int32_t zoneId = 123; + auto ret = audioInterruptService->GetSessionInfoInFocus(audioInterrupt, zoneId); + EXPECT_EQ(SUCCESS, ret); + + audioInterruptService->zonesMap_[zoneId] = nullptr; + ret = audioInterruptService->GetSessionInfoInFocus(audioInterrupt, zoneId); + EXPECT_EQ(SUCCESS, ret); + + auto audioInterruptZone = make_shared(); + audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE}); + AudioInterrupt audioInterrupt2; + audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt2, STOP}); + audioInterruptService->zonesMap_[zoneId] = audioInterruptZone; + ret = audioInterruptService->GetSessionInfoInFocus(audioInterrupt, zoneId); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_054 +* @tc.desc : Test GetAudioSessionUidList_002 +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_054, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + int32_t zoneId = 0; + AudioInterrupt audioInterrupt; + audioInterrupt.isAudioSessionInterrupt = false; + audioInterrupt.uid = 1000; + AudioFocuState audioFocuState = AudioFocuState::DUCK; + std::pair tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState); + + std::shared_ptr audioInterruptZone = std::make_shared(); + audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList); + + audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone}); + auto ret = audioInterruptService->GetAudioSessionUidList(zoneId); + EXPECT_EQ(ret.size(), 0); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_055 +* @tc.desc : Test HandleLowPriorityEvent +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_055, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + int32_t pid = 123; + uint32_t streamId = 123; + audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService(); + auto ret = audioInterruptService->sessionService_->SetAudioSessionScene(pid, AudioSessionScene::MEDIA); + EXPECT_EQ(SUCCESS, ret); + audioInterruptService->sessionService_->SetAudioSessionScene(pid, AudioSessionScene::MEDIA); + ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId); + EXPECT_EQ(true, ret); + audioInterruptService->handler_ = make_shared(); + ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId); + EXPECT_EQ(false, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_056 +* @tc.desc : Test ProcessAudioScene +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_056, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + AudioInterrupt audioInterrupt; + uint32_t incomingStreamId = 123; + int32_t zoneId = 123; + bool shouldReturnSuccess = false; + audioInterruptService->ProcessAudioScene(audioInterrupt, incomingStreamId, zoneId, shouldReturnSuccess); + audioInterruptService->zonesMap_[zoneId] = nullptr; + audioInterruptService->ProcessAudioScene(audioInterrupt, incomingStreamId, zoneId, shouldReturnSuccess); + EXPECT_EQ(true, shouldReturnSuccess); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_057 +* @tc.desc : Test SetQueryBundleNameListCallback +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_057, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + sptr object = new RemoteObjectTestStub(); + auto ret = audioInterruptService->SetQueryBundleNameListCallback(object); + EXPECT_EQ(SUCCESS, ret); + object = nullptr; + ret = audioInterruptService->SetQueryBundleNameListCallback(object); + EXPECT_EQ(ERR_CALLBACK_NOT_REGISTERED, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_058 +* @tc.desc : Test ShouldBypassAudioSessionFocus_001 +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_058, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + int32_t zoneId = 0; + auto pid = getpid(); + auto audioInterruptZone = make_shared(); + AudioInterrupt audioInterrupt; + audioInterrupt.pid = pid; + audioInterrupt.isAudioSessionInterrupt = true; + audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP}); + audioInterruptService->zonesMap_[zoneId] = audioInterruptZone; + auto ret = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, audioInterrupt); + EXPECT_EQ(false, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_059 +* @tc.desc : Test ShouldBypassAudioSessionFocus_002 +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_059, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + int32_t zoneId = 0; + auto pid = getpid(); + auto audioInterruptZone = make_shared(); + AudioInterrupt audioInterrupt; + audioInterrupt.pid = pid; + audioInterrupt.isAudioSessionInterrupt = false; + audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP}); + audioInterruptService->zonesMap_[zoneId] = audioInterruptZone; + audioInterruptService->sessionService_ = nullptr; + auto ret = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, audioInterrupt); + EXPECT_EQ(false, ret); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_060 +* @tc.desc : Test AddToAudioFocusInfoList +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_060, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + auto audioInterruptZone = std::make_shared(); + int32_t zoneId = 123; + AudioInterrupt incomingInterrupt; + AudioFocuState incomingState = STOP; + audioInterruptService->AddToAudioFocusInfoList(audioInterruptZone, zoneId, incomingInterrupt, incomingState); + EXPECT_EQ(false, incomingInterrupt.isAudioSessionInterrupt); + incomingState = ACTIVE; + audioInterruptService->sessionService_ = nullptr; + audioInterruptService->AddToAudioFocusInfoList(audioInterruptZone, zoneId, incomingInterrupt, incomingState); + EXPECT_EQ(false, incomingInterrupt.isAudioSessionInterrupt); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_061 +* @tc.desc : Test HandleIncomingState +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_061, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + int32_t zoneId = 123; + AudioFocuState incomingState; + InterruptEventInternal interruptEvent; + AudioInterrupt incomingInterrupt; + incomingState = STOP; + audioInterruptService->HandleIncomingState(zoneId, incomingState, interruptEvent, incomingInterrupt); + EXPECT_EQ(INTERRUPT_HINT_STOP, interruptEvent.hintType); + incomingState = PAUSE; + audioInterruptService->HandleIncomingState(zoneId, incomingState, interruptEvent, incomingInterrupt); + EXPECT_EQ(INTERRUPT_HINT_PAUSE, interruptEvent.hintType); + incomingState = MUTED; + audioInterruptService->HandleIncomingState(zoneId, incomingState, interruptEvent, incomingInterrupt); + EXPECT_EQ(INTERRUPT_HINT_MUTE, interruptEvent.hintType); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_062 +* @tc.desc : Test SendFocusChangeEvent +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_062, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + int32_t zoneId = 0; + int32_t callbackCategory = static_cast(AudioPolicyServerHandler::REQUEST_CALLBACK_CATEGORY); + AudioInterrupt audioInterrupt; + audioInterruptService->handler_ = make_shared(); + audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC; + audioInterruptService->SendFocusChangeEvent(zoneId, callbackCategory, audioInterrupt); + EXPECT_NE(nullptr, audioInterruptService->handler_); + + callbackCategory = static_cast(AudioPolicyServerHandler::ABANDON_CALLBACK_CATEGORY); + audioInterruptService->SendFocusChangeEvent(zoneId, callbackCategory, audioInterrupt); + EXPECT_NE(nullptr, audioInterruptService->handler_); + + callbackCategory = static_cast(AudioPolicyServerHandler::NONE_CALLBACK_CATEGORY); + audioInterruptService->SendFocusChangeEvent(zoneId, callbackCategory, audioInterrupt); + EXPECT_NE(nullptr, audioInterruptService->handler_); +} + +/** +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_063 +* @tc.desc : Test DispatchInterruptEventWithStreamId +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_063, TestSize.Level1) +{ + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + uint32_t streamId = 0; + InterruptEventInternal interruptEvent; + audioInterruptService->DispatchInterruptEventWithStreamId(streamId, interruptEvent); + streamId = 100001; + audioInterruptService->DispatchInterruptEventWithStreamId(streamId, interruptEvent); + EXPECT_EQ(true, interruptEvent.callbackToApp); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_policy_server_unit_test.cpp b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_policy_server_unit_test.cpp index f3b6cd212bc366641bb31d2dfd857c241571e1ba..0394347d628317fecd0a726e000a1b3200bdbbb5 100644 --- a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_policy_server_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_policy_server_unit_test.cpp @@ -133,6 +133,148 @@ public: #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__) +/** +* @tc.name : Test SetNearlinkDeviceVolume. +* @tc.number: SetNearlinkDeviceVolume_002 +* @tc.desc : Test SetNearlinkDeviceVolume +*/ +HWTEST(AudioPolicyUnitTest, SetNearlinkDeviceVolume_002, TestSize.Level1) +{ + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + + std::string macAddress = "LocalDevice"; + int32_t streamTypeIn = 1; + int32_t volume = 0; + bool updateUi = true; + + int32_t ret = ptrAudioPolicyServer->SetNearlinkDeviceVolume(macAddress, streamTypeIn, volume, updateUi); + EXPECT_EQ(ret, ERR_PERMISSION_DENIED); + + streamTypeIn = 0; + ret = ptrAudioPolicyServer->SetNearlinkDeviceVolume(macAddress, streamTypeIn, volume, updateUi); + EXPECT_EQ(ret, ERR_PERMISSION_DENIED); +} + +/** +* @tc.name : Test AudioPolicyServer. +* @tc.number: SetAudioInterruptCallback_002 +* @tc.desc : Test AudioPolicyServer::SetAudioInterruptCallback +*/ +HWTEST(AudioPolicyUnitTest, SetAudioInterruptCallback_002, TestSize.Level1) +{ + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + EXPECT_NE(ptrAudioPolicyServer, nullptr); + + uint32_t sessionID = 0; + sptr object = nullptr; + uint32_t clientUid = 0; + int32_t zoneID = 0; + + ptrAudioPolicyServer->interruptService_ = nullptr; + ptrAudioPolicyServer->coreService_ = nullptr; + int32_t result = ptrAudioPolicyServer->SetAudioInterruptCallback(sessionID, object, clientUid, zoneID); + EXPECT_EQ(result, ERR_UNKNOWN); + + ptrAudioPolicyServer->interruptService_ = std::make_shared(); + ptrAudioPolicyServer->coreService_ = nullptr; + result = ptrAudioPolicyServer->SetAudioInterruptCallback(sessionID, object, clientUid, zoneID); + EXPECT_EQ(result, ERR_UNKNOWN); + + ptrAudioPolicyServer->interruptService_ = std::make_shared(); + ptrAudioPolicyServer->coreService_ = std::make_shared(); + result = ptrAudioPolicyServer->SetAudioInterruptCallback(sessionID, object, clientUid, zoneID); + EXPECT_EQ(result, ERR_UNKNOWN); +} + +/** +* @tc.name : Test AudioPolicyServer. +* @tc.number: GetDmDeviceType_001 +* @tc.desc : Test AudioPolicyServer::GetDmDeviceType +*/ +HWTEST(AudioPolicyUnitTest, GetDmDeviceType_001, TestSize.Level1) +{ + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + EXPECT_NE(ptrAudioPolicyServer, nullptr); + + uint16_t deviceType = 0; + int32_t result = ptrAudioPolicyServer->GetDmDeviceType(deviceType); + EXPECT_EQ(result, ERROR); +} + +/** +* @tc.name : Test AudioPolicyServer. +* @tc.number: SetSystemVolumeLevelWithDeviceInternal_001 +* @tc.desc : Test AudioPolicyServer::SetSystemVolumeLevelWithDeviceInternal +*/ +HWTEST(AudioPolicyUnitTest, SetSystemVolumeLevelWithDeviceInternal_001, TestSize.Level1) +{ + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + EXPECT_NE(ptrAudioPolicyServer, nullptr); + + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 20; + bool isUpdateUi = false; + DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT; + + int32_t result = ptrAudioPolicyServer->SetSystemVolumeLevelWithDeviceInternal( + streamType, volumeLevel, isUpdateUi, deviceType); + + EXPECT_EQ(result, ptrAudioPolicyServer->SetSingleStreamVolumeWithDevice( + streamType, volumeLevel, isUpdateUi, deviceType)); +} + +/** +* @tc.name : Test AudioPolicyServer. +* @tc.number: GetSystemVolumeLevel_001 +* @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevel +*/ +HWTEST(AudioPolicyUnitTest, GetSystemVolumeLevel_001, TestSize.Level1) +{ + int32_t streamType = 1; + int32_t uid = 0; + int32_t volumeLevel = 0; + + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + int32_t res = ptrAudioPolicyServer->GetSystemVolumeLevel(streamType, uid, volumeLevel); + EXPECT_EQ(res, SUCCESS); + + uid = -1; + res = ptrAudioPolicyServer->GetSystemVolumeLevel(streamType, uid, volumeLevel); + EXPECT_EQ(res, SUCCESS); + + uid = 1; + res = ptrAudioPolicyServer->GetSystemVolumeLevel(streamType, uid, volumeLevel); + EXPECT_EQ(res, SUCCESS); +} + +/** +* @tc.name : Test AudioPolicyServer. +* @tc.number: SetStreamMute_001 +* @tc.desc : Test AudioPolicyServer::SetStreamMute +*/ +HWTEST(AudioPolicyUnitTest, SetStreamMute_001, TestSize.Level1) +{ + int32_t streamTypeIn = 1; + bool mute = false; + int32_t deviceTypeIn = 1; + + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + int32_t res = ptrAudioPolicyServer->SetStreamMute(streamTypeIn, mute, deviceTypeIn); + EXPECT_EQ(res, ERR_PERMISSION_DENIED); +} + /** * @tc.name : Test AudioPolicyServer. * @tc.number: AudioPolicyServer_001 diff --git a/services/audio_policy/test/unittest/audio_offload_stream_unit_test/src/audio_offload_stream_unit_test.cpp b/services/audio_policy/test/unittest/audio_offload_stream_unit_test/src/audio_offload_stream_unit_test.cpp deleted file mode 100644 index 9a6413db0a49919f5c019953441bc10a30bf597e..0000000000000000000000000000000000000000 --- a/services/audio_policy/test/unittest/audio_offload_stream_unit_test/src/audio_offload_stream_unit_test.cpp +++ /dev/null @@ -1,507 +0,0 @@ -/* - * Copyright (c) 2024 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 - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include "gtest/gtest.h" -#include "audio_errors.h" -#include "audio_offload_stream_unit_test.h" -#include "audio_spatialization_service.h" - -using namespace testing::ext; - -namespace OHOS { -namespace AudioStandard { -void AudioOffloadStreamTest::SetUpTestCase(void) {} -void AudioOffloadStreamTest::TearDownTestCase(void) {} -void AudioOffloadStreamTest::SetUp(void) -{ - audioOffloadStream_ = &AudioOffloadStream::GetInstance(); -} -void AudioOffloadStreamTest::TearDown(void) -{ - if (audioOffloadStream_ != nullptr) { - audioOffloadStream_ = nullptr; - } -} - -/** - * @tc.name : HandlePowerStateChanged_NoChange_Test - * @tc.number: AudioOffloadStreamTest_001 - * @tc.desc : Test scenario where the power state does not change. - */ -HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoChange_Test, TestSize.Level2) -{ - audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE; - PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; - audioOffloadStream_->HandlePowerStateChanged(state); - EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE); -} - -/** - * @tc.name : HandlePowerStateChanged_ActiveToInactive_Test - * @tc.number: AudioOffloadStreamTest_002 - * @tc.desc : Test scenario where the power state changes from ACTIVE to INACTIVE. - */ -HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_ActiveToInactive_Test, TestSize.Level2) -{ - audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE; - PowerMgr::PowerState state = PowerMgr::PowerState::INACTIVE; - audioOffloadStream_->HandlePowerStateChanged(state); - EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::INACTIVE); -} - -/** - * @tc.name : HandlePowerStateChanged_NoOffloadSupport_Test - * @tc.number: AudioOffloadStreamTest_003 - * @tc.desc : Test scenario where the device does not support offload. - */ -HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoOffloadSupport_Test, TestSize.Level3) -{ - audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE; - PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; - audioOffloadStream_->HandlePowerStateChanged(state); - EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE); -} - -/** - * @tc.name : HandlePowerStateChanged_OffloadSessionIDNotSet_Test - * @tc.number: audioOffloadStreamTest_004 - * @tc.desc : Test scenario where the offload session ID is not set. - */ -HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDNotSet_Test, TestSize.Level3) -{ - audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE; - PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; - audioOffloadStream_->offloadSessionID_ = std::nullopt; - audioOffloadStream_->HandlePowerStateChanged(state); - EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE); -} - -/** - * @tc.name : HandlePowerStateChanged_OffloadSessionIDSet_Test - * @tc.number: audioOffloadStreamTest_005 - * @tc.desc : Test scenario where the offload session ID is set. - */ -HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDSet_Test, TestSize.Level3) -{ - audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE; - PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE; - audioOffloadStream_->offloadSessionID_ = 1; - audioOffloadStream_->HandlePowerStateChanged(state); - EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE); - - bool oldState = audioOffloadStream_->isOffloadAvailable_; - audioOffloadStream_->isOffloadAvailable_ = false; - audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - audioOffloadStream_->HandlePowerStateChanged(PowerMgr::PowerState::INACTIVE); - audioOffloadStream_->isOffloadAvailable_ = oldState; - EXPECT_FALSE(audioOffloadStream_->GetOffloadAvailableFromXml()); -} - -/** - * @tc.name : CheckStreamOffloadMode_001 - * @tc.number: Audio_OffloadStream_006 - * @tc.desc : Test CheckStreamOffloadMode when offload not available from xml. - */ -HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_001, TestSize.Level3) -{ - // 模拟GetOffloadAvailableFromXml返回false - audioOffloadStream_->isOffloadAvailable_ = false; - AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; - int64_t activateSessionId = 1; - - bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); -} - -/** - * @tc.name : CheckStreamOffloadMode_002 - * @tc.number: Audio_OffloadStream_007 - * @tc.desc : Test CheckStreamOffloadMode when offload not available on current output device. - */ -HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_002, TestSize.Level3) -{ - // 模拟GetOffloadAvailableFromXml返回true - audioOffloadStream_->isOffloadAvailable_ = true; - - AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; - int64_t activateSessionId = 1; - bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); -} - -/** - * @tc.name : CheckStreamOffloadMode_003 - * @tc.number: Audio_OffloadStream_008 - * @tc.desc : Test CheckStreamOffloadMode when offload not available on current output device. - */ -HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_003, TestSize.Level3) -{ - AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT; - int64_t activateSessionId = 6; - AudioStreamChangeInfo streamChangeInfo; - streamChangeInfo.audioRendererChangeInfo.clientUID = 1; - streamChangeInfo.audioRendererChangeInfo.sessionId = 1; - streamChangeInfo.audioRendererChangeInfo.channelCount = 3; - streamChangeInfo.audioRendererChangeInfo.createrUID = 2; - streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW; - streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC; - audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo); - - audioOffloadStream_->isOffloadAvailable_ = true; - audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); - - streamType = AudioStreamType::STREAM_MUSIC; - result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); - - streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC; - audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear(); - audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo); - result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); - - streamChangeInfo.audioRendererChangeInfo.channelCount = 2; - audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear(); - audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo); - result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); - - activateSessionId = 1; - result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); - - streamChangeInfo.audioRendererChangeInfo.sessionId = 1041; - audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear(); - audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo); - result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_FALSE(result); - - activateSessionId = 1041; - streamChangeInfo.audioRendererChangeInfo.sessionId = 1041; - audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear(); - audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo); - result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_EQ(audioOffloadStream_->streamCollector_.GetUid(activateSessionId), 2); - EXPECT_FALSE(result); -} - -/** - * @tc.name : CheckStreamOffloadMode_004 - * @tc.number: Audio_OffloadStream_008 - * @tc.desc : Test CheckStreamOffloadMode with different offloadUID. - */ -HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_004, TestSize.Level3) -{ - AudioOffloadStream audioOffloadStream; - AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; - int64_t activateSessionId = 10; - AudioStreamChangeInfo streamChangeInfo{}; - auto& audioRendererChangeInfo = streamChangeInfo.audioRendererChangeInfo; - audioRendererChangeInfo = {}; - audioRendererChangeInfo.clientUID = 1; - audioRendererChangeInfo.sessionId = activateSessionId; - audioRendererChangeInfo.channelCount = AudioChannel::STEREO; - audioRendererChangeInfo.createrUID = 2; - audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW; - audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_VOIP; - audioOffloadStream.isOffloadAvailable_ = true; - - audioOffloadStream.streamCollector_.AddRendererStream(streamChangeInfo); - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55"; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - - bool result = audioOffloadStream.CheckStreamOffloadMode(activateSessionId, streamType); - EXPECT_TRUE(result); - - audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->createrUID = -1; - audioOffloadStream.CheckStreamOffloadMode(activateSessionId, streamType); - const int32_t UID_AUDIO = 1041; - audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->createrUID = UID_AUDIO; - result = audioOffloadStream.CheckStreamOffloadMode(activateSessionId, streamType); - - audioOffloadStream.SetOffloadStatus(activateSessionId); - EXPECT_EQ(audioOffloadStream.offloadSessionID_, activateSessionId); - audioOffloadStream.SetOffloadStatus(activateSessionId); - audioOffloadStream.SetOffloadStatus(activateSessionId + 1); - EXPECT_EQ(audioOffloadStream.offloadSessionID_, activateSessionId); -} - -/** - * @tc.name : MoveToNewPipe_ShouldReturnError_WhenStreamIsIllegal - * @tc.number: AudioOffloadStreamTest_008 - * @tc.desc : Test if MoveToNewPipe . - */ -HWTEST_F(AudioOffloadStreamTest, MoveToNewPipe_ShouldReturnError_WhenStreamIsIllegal, TestSize.Level3) -{ - AudioStreamChangeInfo streamChangeInfo; - auto& audioRendererChangeInfo = streamChangeInfo.audioRendererChangeInfo; - audioRendererChangeInfo = {}; - audioRendererChangeInfo.clientUID = 1; - audioRendererChangeInfo.sessionId = 1; - audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW; - int32_t ret = audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo); - EXPECT_EQ(ret, SUCCESS); - uint32_t sessionId = 1; - AudioPipeType pipeType = AudioPipeType::PIPE_TYPE_NORMAL_OUT; - // Arrange - int32_t defaultUid = -1; - // Act - auto oldDeviceType = audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_; - audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - int32_t result = audioOffloadStream_->MoveToNewPipe(sessionId, pipeType); - // Assert - EXPECT_NE(result, ERROR); - - result = audioOffloadStream_->MoveToNewPipe(defaultUid, pipeType); - EXPECT_EQ(result, ERROR); - - audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.networkId_ = REMOTE_NETWORK_ID; - result = audioOffloadStream_->MoveToNewPipe(sessionId, PIPE_TYPE_MULTICHANNEL); - EXPECT_EQ(result, ERROR); - - audioOffloadStream_->MoveToOutputDevice(sessionId, BLUETOOTH_SPEAKER); - audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = oldDeviceType; -} - - -/** - * @tc.name : DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsOpened - * @tc.number: AudioOffloadStreamTest_009 - * @tc.desc : Test DynamicUnloadOffloadModule function when offload is opened. - */ -HWTEST_F(AudioOffloadStreamTest, DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsOpened, TestSize.Level3) -{ - // Arrange - audioOffloadStream_->isOffloadOpened_.store(true); - // Act - int32_t result = audioOffloadStream_->DynamicUnloadOffloadModule(); - // Assert - EXPECT_EQ(result, SUCCESS); - EXPECT_FALSE(audioOffloadStream_->isOffloadOpened_.load()); -} - -/** - * @tc.name : DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsNotOpened - * @tc.number: AudioOffloadStreamTest_010 - * @tc.desc : Test DynamicUnloadOffloadModule function when offload is not opened. - */ -HWTEST_F(AudioOffloadStreamTest, DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsNotOpened, TestSize.Level3) -{ - // Arrange - audioOffloadStream_->isOffloadOpened_.store(false); - // Act - int32_t result = audioOffloadStream_->DynamicUnloadOffloadModule(); - // Assert - EXPECT_EQ(result, SUCCESS); -} - -/** - * @tc.name : ReleaseOffloadStream_WhenSessionIdDoesNotMatch - * @tc.number: AudioOffloadStreamTest_011 - * @tc.desc : Test if the offload stream is not released when the session ID does not match. - */ -HWTEST_F(AudioOffloadStreamTest, ReleaseOffloadStream_WhenSessionIdDoesNotMatch, TestSize.Level0) -{ - // Arrange - uint32_t sessionId = 123; - uint32_t differentSessionId = 456; - audioOffloadStream_->offloadSessionID_ = sessionId; - // Act - audioOffloadStream_->RemoteOffloadStreamRelease(differentSessionId); - // Assert - EXPECT_TRUE(audioOffloadStream_->offloadSessionID_.has_value()); - - audioOffloadStream_->RemoteOffloadStreamRelease(sessionId); - EXPECT_FALSE(audioOffloadStream_->offloadSessionID_.has_value()); - audioOffloadStream_->offloadSessionID_ = sessionId; -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_014 - * @tc.desc : Test scenario when spatialization is enabled and effect offload is enabled. - */ -HWTEST_F(AudioOffloadStreamTest, SpatializationEnabledAndEffectOffloadEnabled, TestSize.Level0) -{ - AudioOffloadStream audioOffloadStream; - std::vector allSessions = {1, 2, 3}; - audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions); - - EXPECT_EQ(audioOffloadStream.currentPowerState_, PowerMgr::PowerState::AWAKE); - - auto &service = AudioSpatializationService::GetAudioSpatializationService(); - service.spatializationEnabledReal_ = true; - audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions); - - audioOffloadStream.isOffloadAvailable_ = true; - audioOffloadStream.offloadSessionID_ = 1; - audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions); - - audioOffloadStream.OffloadStreamReleaseCheck(0); - audioOffloadStream.offloadSessionID_.reset(); - audioOffloadStream.OffloadStreamReleaseCheck(0); - service.spatializationEnabledReal_ = false; -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_015 - * @tc.desc : Test ConstructMchAudioModuleInfo Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_015, TestSize.Level0) -{ - DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER; - AudioOffloadStream audioOffloadStream; - AudioModuleInfo ret; - - ret = audioOffloadStream.ConstructMchAudioModuleInfo(deviceType); - EXPECT_EQ(ret.channels, "6"); -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_016 - * @tc.desc : Test LoadMchModule Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_016, TestSize.Level0) -{ - AudioOffloadStream audioOffloadStream; - int32_t ret; - - ret = audioOffloadStream.LoadMchModule(); - EXPECT_EQ(ret, SUCCESS); -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_017 - * @tc.desc : Test ConstructOffloadAudioModuleInfo Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_017, TestSize.Level0) -{ - DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER; - AudioOffloadStream audioOffloadStream; - AudioModuleInfo ret; - - ret = audioOffloadStream.ConstructOffloadAudioModuleInfo(deviceType); - EXPECT_EQ(ret.channels, "2"); -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_018 - * @tc.desc : Test UnloadMchModule Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_018, TestSize.Level0) -{ - AudioOffloadStream audioOffloadStream; - int32_t ret; - - ret = audioOffloadStream.UnloadMchModule(); - EXPECT_NE(ret, SUCCESS); -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_019 - * @tc.desc : Test LoadOffloadModule Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_019, TestSize.Level0) -{ - AudioIOHandle audioIOHandle = 3; - AudioOffloadStream audioOffloadStream; - int32_t ret; - - ret = audioOffloadStream.LoadOffloadModule(); - EXPECT_EQ(ret, SUCCESS); - - audioOffloadStream.audioIOHandleMap_.IOHandles_[OFFLOAD_PRIMARY_SPEAKER] = audioIOHandle; - ret = audioOffloadStream.LoadOffloadModule(); - EXPECT_EQ(ret, SUCCESS); -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_020 - * @tc.desc : Test UnloadOffloadModule Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_020, TestSize.Level0) -{ - AudioOffloadStream audioOffloadStream; - int32_t ret; - - audioOffloadStream.isOffloadOpened_.store(true); - ret = audioOffloadStream.UnloadOffloadModule(); - EXPECT_NE(ret, SUCCESS); -} - -/** - * @tc.name : SpatializationEnabledAndEffectOffloadEnabled - * @tc.number: AudioOffloadStreamTest_022 - * @tc.desc : Test OffloadStreamSetCheck Interface. - */ -HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_022, TestSize.Level0) -{ - uint32_t sessionId = 100; - AudioOffloadStream audioOffloadStream; - AudioStreamChangeInfo streamChangeInfo; - audioOffloadStream.isOffloadAvailable_ = true; - auto& audioRendererChangeInfo = streamChangeInfo.audioRendererChangeInfo; - audioRendererChangeInfo = {}; - audioRendererChangeInfo.clientUID = 1; - audioRendererChangeInfo.sessionId = sessionId; - audioRendererChangeInfo.channelCount = AudioChannel::STEREO; - audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW; - audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_VOIP; - - audioOffloadStream.streamCollector_.AddRendererStream(streamChangeInfo); - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55"; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - audioOffloadStream.OffloadStreamSetCheck(sessionId); - EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceNetworkId(), LOCAL_NETWORK_ID); - EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceType(), DEVICE_TYPE_SPEAKER); - audioOffloadStream.OffloadStreamSetCheck(sessionId); - audioOffloadStream.OffloadStreamSetCheck(1); - - audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->channelCount = AudioChannel::CHANNEL_3; - EXPECT_FALSE(audioOffloadStream.CheckStreamMultichannelMode(sessionId)); - audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->channelCount = AudioChannel::STEREO; - - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = REMOTE_NETWORK_ID; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE; - audioOffloadStream.OffloadStreamSetCheck(sessionId); - EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceNetworkId(), REMOTE_NETWORK_ID); - - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = ""; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE; - audioOffloadStream.OffloadStreamSetCheck(sessionId); - EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceMacAddr(), "00:11:22:33:44:55"); - EXPECT_FALSE(audioOffloadStream.CheckStreamMultichannelMode(sessionId)); - - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = ""; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = ""; - audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE; - audioOffloadStream.OffloadStreamSetCheck(sessionId); - EXPECT_EQ(audioOffloadStream.streamCollector_.GetStreamType(sessionId), STREAM_MUSIC); - audioOffloadStream.ResetOffloadStatus(sessionId); - EXPECT_FALSE(audioOffloadStream.offloadSessionID_.has_value()); -} -} // 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 cf1e4e6ae59ff44d28bf25ea0c0d25c2363c1918..472c6b337e19490c28d2a919f7c6c4f9dad371ef 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 @@ -279,7 +279,8 @@ HWTEST_F(AudioPipeManagerUnitTest, GetUnusedPipe_001, TestSize.Level1) pipe1->streamDescriptors_.clear(); audioPipeManager->AddAudioPipeInfo(pipe1); - auto unusedPipes = audioPipeManager->GetUnusedPipe(); + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + auto unusedPipes = audioPipeManager->GetUnusedPipe(deviceType); EXPECT_EQ(unusedPipes.size(), 1); EXPECT_EQ(unusedPipes[0]->routeFlag_, AUDIO_OUTPUT_FLAG_FAST); } @@ -299,7 +300,8 @@ HWTEST_F(AudioPipeManagerUnitTest, GetUnusedPipe_002, TestSize.Level1) pipe1->routeFlag_ = AUDIO_OUTPUT_FLAG_FAST; pipe1->streamDescriptors_.push_back(std::make_shared()); audioPipeManager->AddAudioPipeInfo(pipe1); - auto unusedPipes = audioPipeManager->GetUnusedPipe(); + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + auto unusedPipes = audioPipeManager->GetUnusedPipe(deviceType); EXPECT_EQ(unusedPipes.size(), 0); } @@ -318,7 +320,50 @@ HWTEST_F(AudioPipeManagerUnitTest, GetUnusedPipe_003, TestSize.Level1) pipe1->routeFlag_ = 0; pipe1->streamDescriptors_.clear(); audioPipeManager->AddAudioPipeInfo(pipe1); - auto unusedPipes = audioPipeManager->GetUnusedPipe(); + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + auto unusedPipes = audioPipeManager->GetUnusedPipe(deviceType); + EXPECT_EQ(unusedPipes.size(), 0); +} + +/** + * @tc.name: GetUnusedPipe_004 + * @tc.desc: Test GetUnusedPipe when pipe meets streamDescriptors empty, routeFlag is not special but a2dp is unused. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioPipeManagerUnitTest, GetUnusedPipe_004, TestSize.Level4) +{ + auto audioPipeManager = AudioPipeManager::GetPipeManager(); + audioPipeManager->curPipeList_.clear(); + + std::shared_ptr pipe1 = std::make_shared(); + pipe1->adapterName_ = "a2dp"; + pipe1->routeFlag_ = 0; + pipe1->streamDescriptors_.clear(); + audioPipeManager->AddAudioPipeInfo(pipe1); + DeviceType deviceType = DEVICE_TYPE_SPEAKER; + auto unusedPipes = audioPipeManager->GetUnusedPipe(deviceType); + EXPECT_EQ(unusedPipes.size(), 1); +} + +/** + * @tc.name: GetUnusedPipe_005 + * @tc.desc: Test GetUnusedPipe when pipe meets streamDescriptors empty, routeFlag is not special nut a2dp is used. + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioPipeManagerUnitTest, GetUnusedPipe_005, TestSize.Level4) +{ + auto audioPipeManager = AudioPipeManager::GetPipeManager(); + audioPipeManager->curPipeList_.clear(); + + std::shared_ptr pipe1 = std::make_shared(); + pipe1->adapterName_ = "a2dp"; + pipe1->routeFlag_ = 0; + pipe1->streamDescriptors_.clear(); + audioPipeManager->AddAudioPipeInfo(pipe1); + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + auto unusedPipes = audioPipeManager->GetUnusedPipe(deviceType); EXPECT_EQ(unusedPipes.size(), 0); } diff --git a/services/audio_policy/test/unittest/audio_pipe_selector_unit_test/src/audio_pipe_selector_unit_test.cpp b/services/audio_policy/test/unittest/audio_pipe_selector_unit_test/src/audio_pipe_selector_unit_test.cpp index 33afb74058fd2ce530197d09d675c88e3cc88486..da9845de50d286827c2d47a3f77c6711d7223d25 100644 --- a/services/audio_policy/test/unittest/audio_pipe_selector_unit_test/src/audio_pipe_selector_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_pipe_selector_unit_test/src/audio_pipe_selector_unit_test.cpp @@ -1,20 +1,20 @@ /* -* Copyright (c) 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 -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#include "audio_policy_utils.h" + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ #include "audio_pipe_selector_unit_test.h" -#include "audio_stream_descriptor.h" + +#include "audio_policy_utils.h" #include "audio_stream_descriptor.h" #include "audio_stream_enum.h" @@ -23,6 +23,9 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { +static const uint32_t TEST_SESSION_ID_BASE = 100000; +static const uint32_t TEST_STREAM_1_SESSION_ID = 100001; + void AudioPipeSelectorUnitTest::SetUpTestCase(void) {} void AudioPipeSelectorUnitTest::TearDownTestCase(void) {} void AudioPipeSelectorUnitTest::SetUp(void) {} @@ -404,12 +407,12 @@ HWTEST_F(AudioPipeSelectorUnitTest, FetchPipeAndExecute_001, TestSize.Level1) } /** - * @tc.name: UpdataDeviceStreamInfo_001 - * @tc.desc: Test UpdataDeviceStreamInfo + * @tc.name: UpdateDeviceStreamInfo_001 + * @tc.desc: Test UpdateDeviceStreamInfo * @tc.type: FUNC * @tc.require: #I5Y4MZ */ -HWTEST_F(AudioPipeSelectorUnitTest, UpdataDeviceStreamInfo_001, TestSize.Level1) +HWTEST_F(AudioPipeSelectorUnitTest, UpdateDeviceStreamInfo_001, TestSize.Level1) { std::shared_ptr streamDesc = std::make_shared(); @@ -418,24 +421,24 @@ HWTEST_F(AudioPipeSelectorUnitTest, UpdataDeviceStreamInfo_001, TestSize.Level1) auto audioPipeSelector = AudioPipeSelector::GetPipeSelector(); // test empty - audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo); + audioPipeSelector->UpdateDeviceStreamInfo(streamDesc, streamPropInfo); std::shared_ptr temp = nullptr; streamDesc->newDeviceDescs_.push_back(temp); - audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo); + audioPipeSelector->UpdateDeviceStreamInfo(streamDesc, streamPropInfo); streamPropInfo = std::make_shared(); - audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo); + audioPipeSelector->UpdateDeviceStreamInfo(streamDesc, streamPropInfo); streamDesc->newDeviceDescs_.front() = std::make_shared(); - audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo); + audioPipeSelector->UpdateDeviceStreamInfo(streamDesc, streamPropInfo); // test nullptr streamPropInfo->format_ = AudioSampleFormat::SAMPLE_S16LE; streamPropInfo->sampleRate_ = static_cast(AudioSamplingRate::SAMPLE_RATE_48000); streamPropInfo->channels_ = AudioChannel::STEREO; - audioPipeSelector->UpdataDeviceStreamInfo(streamDesc, streamPropInfo); + audioPipeSelector->UpdateDeviceStreamInfo(streamDesc, streamPropInfo); EXPECT_EQ(streamDesc->newDeviceDescs_.front()->audioStreamInfo_.front().format, streamPropInfo->format_); EXPECT_EQ(*(streamDesc->newDeviceDescs_.front()->audioStreamInfo_.front().samplingRate.rbegin()), @@ -509,29 +512,29 @@ HWTEST_F(AudioPipeSelectorUnitTest, FetchPipesAndExecute_002, TestSize.Level4) } /** - * @tc.name: IncomingConcurrency_001 - * @tc.desc: Test IncomingConcurrency cmpStream->audioMode_ == AUDIO_MODE_RECORD + * @tc.name: CheckAndHandleIncomingConcurrency_001 + * @tc.desc: Test CheckAndHandleIncomingConcurrency cmpStream->audioMode_ == AUDIO_MODE_RECORD * && stream->audioMode_ == AUDIO_MODE_RECORD. * @tc.type: FUNC * @tc.require: #I5Y4MZ */ -HWTEST_F(AudioPipeSelectorUnitTest, IncomingConcurrency_001, TestSize.Level4) +HWTEST_F(AudioPipeSelectorUnitTest, CheckAndHandleIncomingConcurrency_001, TestSize.Level4) { std::shared_ptr stream = std::make_shared(); std::shared_ptr cmpStream = std::make_shared(); auto audioPipeSelector = AudioPipeSelector::GetPipeSelector(); - audioPipeSelector->IncomingConcurrency(stream, cmpStream); + audioPipeSelector->CheckAndHandleIncomingConcurrency(stream, cmpStream); cmpStream->audioMode_ = AUDIO_MODE_RECORD; stream->audioMode_ = AUDIO_MODE_PLAYBACK; - audioPipeSelector->IncomingConcurrency(stream, cmpStream); + audioPipeSelector->CheckAndHandleIncomingConcurrency(stream, cmpStream); cmpStream->audioMode_ = AUDIO_MODE_PLAYBACK; stream->audioMode_ = AUDIO_MODE_RECORD; - audioPipeSelector->IncomingConcurrency(stream, cmpStream); + audioPipeSelector->CheckAndHandleIncomingConcurrency(stream, cmpStream); cmpStream->audioMode_ = AUDIO_MODE_RECORD; stream->audioMode_ = AUDIO_MODE_RECORD; - audioPipeSelector->IncomingConcurrency(stream, cmpStream); + audioPipeSelector->CheckAndHandleIncomingConcurrency(stream, cmpStream); EXPECT_EQ(cmpStream->routeFlag_, AUDIO_INPUT_FLAG_NORMAL); } @@ -568,19 +571,81 @@ HWTEST_F(AudioPipeSelectorUnitTest, ProcessConcurrency_001, TestSize.Level4) cmpStream->sessionId_ = 1; auto audioPipeSelector = AudioPipeSelector::GetPipeSelector(); - bool ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream); + std::vector> streamsToMove; + bool ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream, streamsToMove); EXPECT_EQ(stream->streamAction_, AUDIO_STREAM_ACTION_DEFAULT); EXPECT_FALSE(ret); cmpStream->audioMode_ = AUDIO_MODE_RECORD; - ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream); + ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream, streamsToMove); EXPECT_EQ(cmpStream->routeFlag_, AUDIO_INPUT_FLAG_NORMAL); stream->audioMode_ = AUDIO_MODE_RECORD; - ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream); + ret = audioPipeSelector->ProcessConcurrency(stream, cmpStream, streamsToMove); EXPECT_TRUE(ret); } +/** + * @tc.name: AudioPipeSelectorUnitTest_MoveStreamsToNormalPipes_001 + * @tc.number: MoveStreamsToNormalPipes_001 + * @tc.desc: Test MoveStreamsToNormalPipes cases + */ +HWTEST_F(AudioPipeSelectorUnitTest, MoveStreamsToNormalPipes_001, TestSize.Level4) +{ + auto testSelector = AudioPipeSelector::GetPipeSelector(); + std::vector> testStreamsToMove; + std::vector> testPipeInfoList; + // Make a normal pipe + auto normalPipe = std::make_shared(); + normalPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL; + testPipeInfoList.push_back(normalPipe); + + // Make a offload pipe and add one remove stream + auto offloadPipe = std::make_shared(); + offloadPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_LOWPOWER; + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + offloadPipe->AddStream(stream); + testStreamsToMove.push_back(stream); + testPipeInfoList.push_back(offloadPipe); + + testSelector->MoveStreamsToNormalPipes(testStreamsToMove, testPipeInfoList); + EXPECT_EQ(true, normalPipe->ContainStream(TEST_STREAM_1_SESSION_ID)); + EXPECT_EQ(PIPE_ACTION_UPDATE, normalPipe->GetAction()); + EXPECT_EQ(false, offloadPipe->ContainStream(TEST_STREAM_1_SESSION_ID)); +} + +/** + * @tc.name: AudioPipeSelectorUnitTest_MoveStreamsToNormalPipes_002 + * @tc.number: MoveStreamsToNormalPipes_002 + * @tc.desc: Test MoveStreamsToNormalPipes cases + */ +HWTEST_F(AudioPipeSelectorUnitTest, MoveStreamsToNormalPipes_002, TestSize.Level4) +{ + auto testSelector = AudioPipeSelector::GetPipeSelector(); + std::vector> testStreamsToMove; + std::vector> testPipeInfoList; + // Make a normal pipe + auto normalPipe = std::make_shared(); + normalPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_NORMAL; + normalPipe->SetAction(PIPE_ACTION_NEW); + testPipeInfoList.push_back(normalPipe); + + // Make a offload pipe and add one remove stream + auto offloadPipe = std::make_shared(); + offloadPipe->routeFlag_ = AUDIO_OUTPUT_FLAG_LOWPOWER; + auto stream = std::make_shared(); + stream->sessionId_ = TEST_STREAM_1_SESSION_ID; + offloadPipe->AddStream(stream); + testStreamsToMove.push_back(stream); + testPipeInfoList.push_back(offloadPipe); + + testSelector->MoveStreamsToNormalPipes(testStreamsToMove, testPipeInfoList); + EXPECT_EQ(true, normalPipe->ContainStream(TEST_STREAM_1_SESSION_ID)); + EXPECT_EQ(PIPE_ACTION_NEW, normalPipe->GetAction()); + EXPECT_EQ(false, offloadPipe->ContainStream(TEST_STREAM_1_SESSION_ID)); +} + /** * @tc.name: ConvertStreamDescToPipeInfo_002 * @tc.desc: Test ConvertStreamDescToPipeInfo pipeInfoPtr->name_ == "dp_multichannel_output". diff --git a/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp index 687c6566f23b6d88a9b5f28105ae8d5cc92479ba..52047f59cfe09749a8c5ff218e17c431c7a90496 100644 --- a/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp @@ -27,6 +27,20 @@ void AudioPolicyManagerUnitTest::TearDownTestCase(void) {} void AudioPolicyManagerUnitTest::SetUp(void) {} void AudioPolicyManagerUnitTest::TearDown(void) {} +class AudioManagerDeviceChangeCallbackStub : public AudioManagerDeviceChangeCallback { +public: + ~AudioManagerDeviceChangeCallbackStub() {} + + void OnDeviceChange(const DeviceChangeAction &deviceChangeAction) override {} +}; + +class AudioPreferredOutputDeviceChangeCallbackStub : public AudioPreferredOutputDeviceChangeCallback { +public: + ~AudioPreferredOutputDeviceChangeCallbackStub() {} + + void OnPreferredInputDeviceUpdated(const std::vector> &desc) {} +}; + /** * @tc.name : Test AudioPolicyManager. * @tc.number: AudioPolicyManagerUnitTest_001. @@ -809,5 +823,25 @@ HWTEST(AudioPolicyManager, SetNearlinkDeviceVolume_002, TestSize.Level1) auto result = audioPolicyManager_->SetNearlinkDeviceVolume(macAddress, volumeType, volume, updateUi); EXPECT_EQ(result, ERROR); } + +/** +* @tc.name : Test AudioPolicyManager. +* @tc.number: SelectOutputDevice_001. +* @tc.desc : Test SetNearlinkDeviceVolume. +*/ +HWTEST(AudioPolicyManager, SelectOutputDevice_001, TestSize.Level1) +{ + auto audioPolicyManager_ = std::make_shared(); + ASSERT_TRUE(audioPolicyManager_ != nullptr); + sptr audioRendererFilter; + std::vector> audioDeviceDescriptors01; + auto ret = audioPolicyManager_->SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors01); + EXPECT_EQ(ret, -1); + + // SelectOutputDevice接口中存在直接使用魔鬼数字20作为if的判断条件 + std::vector> audioDeviceDescriptors02(21); + ret = audioPolicyManager_->SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors02); + EXPECT_EQ(ret, -1); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_policy_server_handler_unit_test/src/audio_policy_server_handler_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_server_handler_unit_test/src/audio_policy_server_handler_unit_test.cpp index 53122ccbc539d4ecba19ac3a4c95e05a3686bf20..3e2409c3f2b23909219b136e6d58a6b73ffa359b 100644 --- a/services/audio_policy/test/unittest/audio_policy_server_handler_unit_test/src/audio_policy_server_handler_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_policy_server_handler_unit_test/src/audio_policy_server_handler_unit_test.cpp @@ -838,8 +838,6 @@ HWTEST(AudioPolicyServerHandlerUnitTest, HandleServiceEvent_001, TestSize.Level2 audioPolicyServerHandler_->HandleServiceEvent(eventId, event); eventId = AudioPolicyServerHandler::EventAudioServerCmd::MICROPHONE_BLOCKED; audioPolicyServerHandler_->HandleServiceEvent(eventId, event); - eventId = AudioPolicyServerHandler::EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT; - audioPolicyServerHandler_->HandleServiceEvent(eventId, event); EXPECT_EQ(audioPolicyServerHandler_->audioPolicyClientProxyAPSCbsMap_.size(), 1); } @@ -1208,19 +1206,6 @@ HWTEST(AudioPolicyServerHandlerUnitTest, AudioPolicyServerHandlerUnitTest_006, T bool ret = audioPolicyServerHandler_->SendHeadTrackingDeviceChangeEvent(changeInfo); EXPECT_NE(ret, false); } -/** - * @tc.name : AudioPolicyServerHandlerUnitTest_007 - * @tc.number: AudioPolicyServerHandlerUnitTest_007 - * @tc.desc : Test HandleInterruptEventWithSessionId function when eventContextObj is nullptr. - */ -HWTEST(AudioPolicyServerHandlerUnitTest, AudioPolicyServerHandlerUnitTest_007, TestSize.Level2) -{ - auto audioPolicyServerHandler_ = std::make_shared(); - EXPECT_NE(audioPolicyServerHandler_, nullptr); - AudioPipeType pipeType = PIPE_TYPE_UNKNOWN; - bool ret = audioPolicyServerHandler_->SendPipeStreamCleanEvent(PIPE_TYPE_UNKNOWN); - EXPECT_NE(ret, false); -} /** * @tc.name : SendFormatUnsupportedErrorEvent_001 diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h b/services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..673ff01feab07c7a78d0a24d3952bc50cc6ca6f7 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2024 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_POLICY_SERVICE_EXTENDED_UNIT_TEST_H +#define AUDIO_POLICY_SERVICE_EXTENDED_UNIT_TEST_H + +#include + +#include "audio_policy_service.h" +#include "audio_policy_server.h" +#include "audio_policy_utils.h" +#include "audio_info.h" +#include "message_parcel.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioPolicyServiceExtendedUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; + +class RemoteObjectTestStub : public IRemoteObject { +public: + RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {} + int32_t GetObjectRefCount() { return 0; }; + int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; }; + bool AddDeathRecipient(const sptr &recipient) { return true; }; + bool RemoveDeathRecipient(const sptr &recipient) { return true; }; + int Dump(int fd, const std::vector &args) { return 0; }; + + DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub"); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_POLICY_SERVICE_EXTENDED_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..979e9feccd5b59457c068cc7a8e29e8a81940fe5 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp @@ -0,0 +1,866 @@ +/* + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_policy_service_extended_unit_test.h" +#include "get_server_util.h" + +#include +#include +#include +#include "audio_info.h" +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +bool g_hasPermission = false; +static const std::string INNER_CAPTURER_SINK_LEGACY = "InnerCapturer"; +const int32_t CONNECTING_NUMBER = 10; +const int32_t TEST_SESSIONID = MIN_STREAMID + 1010; +const int32_t ROUTER_MAP_ID0 = 1000; +const int32_t ROUTER_MAP_ID1 = 1001; +const int32_t ROUTER_MAP_ID2 = 1002; +const int32_t ROUTER_MAP_ID3 = 1003; +const int32_t ROUTER_MAP_ID4 = 1004; +const int32_t ROUTER_MAP_ID5 = 1005; +const int32_t ROUTER_MAP_ID6 = 1006; +const int32_t VALUE_ZERO = 0; +const int32_t DEFAULT_VOLUME_LEVEL = 7; +const int32_t G_UNKNOWN_PID = -1; +const uint32_t CHANNELS = 2; +const uint32_t RATE = 4; + +void AudioPolicyServiceExtendedUnitTest::SetUpTestCase(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::SetUpTestCase start-end"); +} +void AudioPolicyServiceExtendedUnitTest::TearDownTestCase(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::TearDownTestCase start-end"); +} +void AudioPolicyServiceExtendedUnitTest::SetUp(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::SetUp start-end"); +} +void AudioPolicyServiceExtendedUnitTest::TearDown(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::TearDown start-end"); +} + +static AudioPolicyServer* GetServerPtr() +{ + return GetServerUtil::GetServerPtr(); +} + +static void GetPermission() +{ + if (!g_hasPermission) { + uint64_t tokenId; + constexpr int perNum = 10; + const char *perms[perNum] = { + "ohos.permission.MICROPHONE", + "ohos.permission.MANAGE_INTELLIGENT_VOICE", + "ohos.permission.MANAGE_AUDIO_CONFIG", + "ohos.permission.MICROPHONE_CONTROL", + "ohos.permission.MODIFY_AUDIO_SETTINGS", + "ohos.permission.ACCESS_NOTIFICATION_POLICY", + "ohos.permission.USE_BLUETOOTH", + "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO", + "ohos.permission.RECORD_VOICE_CALL", + "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS", + }; + + NativeTokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 10, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "audio_policy_service_unit_test", + .aplStr = "system_basic", + }; + tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); + g_hasPermission = true; + } +} + +static const std::vector deviceTypes = { + DEVICE_TYPE_NONE, + DEVICE_TYPE_INVALID, + DEVICE_TYPE_EARPIECE, + DEVICE_TYPE_SPEAKER, + DEVICE_TYPE_WIRED_HEADSET, + DEVICE_TYPE_WIRED_HEADPHONES, + DEVICE_TYPE_BLUETOOTH_SCO, + DEVICE_TYPE_BLUETOOTH_A2DP, + DEVICE_TYPE_MIC, + DEVICE_TYPE_WAKEUP, + DEVICE_TYPE_USB_HEADSET, + DEVICE_TYPE_DP, + DEVICE_TYPE_REMOTE_CAST, + DEVICE_TYPE_FILE_SINK, + DEVICE_TYPE_FILE_SOURCE, + DEVICE_TYPE_EXTERN_CABLE, + DEVICE_TYPE_DEFAULT, + DEVICE_TYPE_USB_ARM_HEADSET, + DEVICE_TYPE_HDMI +}; + +static const std::vector streamSetStates = { + STREAM_PAUSE, + STREAM_RESUME, + STREAM_MUTE, + STREAM_UNMUTE +}; + +static const std::vectorisConnecteds = { + true, + false +}; +static const std::vectorflags = { + NO_A2DP_DEVICE, + A2DP_NOT_OFFLOAD, + A2DP_OFFLOAD +}; +static const std::vectorpipeTypes = { + PIPE_TYPE_UNKNOWN, + PIPE_TYPE_NORMAL_OUT, + PIPE_TYPE_NORMAL_IN, + PIPE_TYPE_OFFLOAD, + PIPE_TYPE_MULTICHANNEL +}; +static const std::vectorpreferredTypes = { + Media::MediaMonitor::MEDIA_RENDER, + Media::MediaMonitor::CALL_RENDER, + Media::MediaMonitor::RING_RENDER, + Media::MediaMonitor::TONE_RENDER, + Media::MediaMonitor::CALL_CAPTURE, + Media::MediaMonitor::RECORD_CAPTURE +}; +static const std::vectorstreamUsages = { + STREAM_USAGE_INVALID, + STREAM_USAGE_UNKNOWN, + STREAM_USAGE_MEDIA, + STREAM_USAGE_MUSIC, + STREAM_USAGE_VOICE_COMMUNICATION, + STREAM_USAGE_VOICE_ASSISTANT, + STREAM_USAGE_ALARM, + STREAM_USAGE_VOICE_MESSAGE, + STREAM_USAGE_NOTIFICATION_RINGTONE, + STREAM_USAGE_RINGTONE, + STREAM_USAGE_NOTIFICATION, + STREAM_USAGE_SYSTEM, + STREAM_USAGE_MOVIE, + STREAM_USAGE_GAME, + STREAM_USAGE_AUDIOBOOK, + STREAM_USAGE_NAVIGATION, + STREAM_USAGE_DTMF, + STREAM_USAGE_ENFORCED_TONE, + STREAM_USAGE_ULTRASONIC, + STREAM_USAGE_VIDEO_COMMUNICATION, + STREAM_USAGE_RANGING, + STREAM_USAGE_VOICE_MODEM_COMMUNICATION, + STREAM_USAGE_VOICE_RINGTONE, + STREAM_USAGE_VOICE_CALL_ASSISTANT, + STREAM_USAGE_MAX +}; +static const std::vectoraudioStreamTypes = { + STREAM_DEFAULT, + STREAM_VOICE_CALL, + STREAM_MUSIC, + STREAM_RING, + STREAM_MEDIA, + STREAM_VOICE_ASSISTANT, + STREAM_SYSTEM, + STREAM_ALARM, + STREAM_NOTIFICATION, + STREAM_BLUETOOTH_SCO, + STREAM_ENFORCED_AUDIBLE, + STREAM_DTMF, + STREAM_TTS, + STREAM_RECORDING, + STREAM_MOVIE, + STREAM_GAME, + STREAM_SPEECH, + STREAM_SYSTEM_ENFORCED, + STREAM_ULTRASONIC, + STREAM_WAKEUP, + STREAM_VOICE_MESSAGE, + STREAM_NAVIGATION, + STREAM_INTERNAL_FORCE_STOP, + STREAM_SOURCE_VOICE_CALL, + STREAM_VOICE_COMMUNICATION, + STREAM_VOICE_RING, + STREAM_VOICE_CALL_ASSISTANT, + STREAM_TYPE_MAX, + STREAM_ALL +}; +static const std::vectorisMutes = { + true, + false +}; +static const std::vectordeviceRoles = { + DEVICE_ROLE_NONE, + INPUT_DEVICE, + OUTPUT_DEVICE, + DEVICE_ROLE_MAX +}; +static const std::vectordeviceFlags = { + NONE_DEVICES_FLAG, + OUTPUT_DEVICES_FLAG, + INPUT_DEVICES_FLAG, + ALL_DEVICES_FLAG, + DISTRIBUTED_OUTPUT_DEVICES_FLAG, + DISTRIBUTED_INPUT_DEVICES_FLAG, + ALL_DISTRIBUTED_DEVICES_FLAG, + ALL_L_D_DEVICES_FLAG, + DEVICE_FLAG_MAX +}; +static const std::vectoraudioSampleFormats = { + SAMPLE_U8, + SAMPLE_S16LE, + SAMPLE_S24LE, + SAMPLE_S32LE, + SAMPLE_F32LE, + INVALID_WIDTH +}; +static const std::vectoraudioScenes = { + AUDIO_SCENE_INVALID, + AUDIO_SCENE_DEFAULT, + AUDIO_SCENE_RINGING, + AUDIO_SCENE_PHONE_CALL, + AUDIO_SCENE_PHONE_CHAT, + AUDIO_SCENE_CALL_START, + AUDIO_SCENE_CALL_END, + AUDIO_SCENE_VOICE_RINGING, + AUDIO_SCENE_MAX +}; +static const std::vectoraudioRingerModes = { + RINGER_MODE_SILENT, + RINGER_MODE_VIBRATE, + RINGER_MODE_NORMAL +}; +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: CaptureConcurrentCheck +* @tc.desc : Test CaptureConcurrentCheck. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, CaptureConcurrentCheck, TestSize.Level1) +{ + uint32_t sessionId = 0; + int32_t ret = AudioPolicyService::GetAudioPolicyService().CaptureConcurrentCheck(sessionId); + EXPECT_EQ(ret, ERR_NULL_POINTER); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetDefaultAdapterEnable +* @tc.desc : Test SetDefaultAdapterEnable. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetDefaultAdapterEnable, TestSize.Level1) +{ + bool isEnable = false; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SetDefaultAdapterEnable(isEnable); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UnregisterBluetoothListener +* @tc.desc : Test UnregisterBluetoothListener. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UnregisterBluetoothListener, TestSize.Level1) +{ +#ifdef BLUETOOTH_ENABLE + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UnregisterBluetoothListener(); + ); +#endif +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: OnServiceConnected +* @tc.desc : Test OnServiceConnected. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, OnServiceConnected, TestSize.Level1) +{ + AudioServiceIndex serviceIndex = AudioServiceIndex::HDI_SERVICE_INDEX; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().OnServiceConnected(serviceIndex); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetDefaultDeviceLoadFlag +* @tc.desc : Test SetDefaultDeviceLoadFlag. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetDefaultDeviceLoadFlag, TestSize.Level1) +{ + bool isLoad = false; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SetDefaultDeviceLoadFlag(isLoad); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RestoreSession +* @tc.desc : Test RestoreSession. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RestoreSession, TestSize.Level1) +{ + uint32_t sessionId = 0; + RestoreInfo restoreInfo = {}; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RestoreSession(sessionId, restoreInfo); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateSpatializationSupported +* @tc.desc : Test UpdateSpatializationSupported. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateSpatializationSupported, TestSize.Level1) +{ + std::string macAddress = "02:7f:3a:9d:1c:5b"; + bool support = false; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateSpatializationSupported(macAddress, support); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SubscribeSafeVolumeEvent +* @tc.desc : Test SubscribeSafeVolumeEvent. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SubscribeSafeVolumeEvent, TestSize.Level1) +{ + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SubscribeSafeVolumeEvent(); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: getFastControlParam +* @tc.desc : Test getFastControlParam. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, getFastControlParam, TestSize.Level1) +{ + bool ret = AudioPolicyService::GetAudioPolicyService().getFastControlParam(); + EXPECT_EQ(ret, true); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: NotifyAccountsChanged +* @tc.desc : Test NotifyAccountsChanged. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, NotifyAccountsChanged, TestSize.Level1) +{ + int id = 1; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().NotifyAccountsChanged(id); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetDistributedRoutingRoleInfo +* @tc.desc : Test GetDistributedRoutingRoleInfo. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetDistributedRoutingRoleInfo, TestSize.Level1) +{ + DistributedRoutingInfo ret = AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo(); + EXPECT_EQ(ret.descriptor, nullptr); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetAndSaveClientType +* @tc.desc : Test GetAndSaveClientType. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetAndSaveClientType, TestSize.Level1) +{ + uint32_t uid = 1; + std::string bundleName = "test"; + int32_t ret = AudioPolicyService::GetAudioPolicyService().GetAndSaveClientType(uid, bundleName); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission +* @tc.desc : Test UpdateDescWhenNoBTPermission. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission, TestSize.Level1) +{ + vector> descs; + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + descs.push_back(std::move(audioDeviceDescriptor)); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(descs); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RegisterDataObserver +* @tc.desc : Test RegisterDataObserver. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RegisterDataObserver, TestSize.Level1) +{ + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RegisterDataObserver(); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RegisterRemoteDevStatusCallback +* @tc.desc : Test RegisterRemoteDevStatusCallback. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RegisterRemoteDevStatusCallback, TestSize.Level1) +{ +#ifdef FEATURE_DEVICE_MANAGER + auto server = GetServerUtil::GetServerPtr(); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RegisterRemoteDevStatusCallback(); + ); +#endif +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RestoreSession_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RestoreSession_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest RestoreSession_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + const int32_t testID = 0; + RestoreInfo restoreInfo; + GetServerPtr()->audioPolicyService_.RestoreSession(testID, restoreInfo); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetDistributedRoutingRoleInfo_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetDistributedRoutingRoleInfo_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetDistributedRoutingRoleInfo_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + GetServerPtr()->audioPolicyService_.GetDistributedRoutingRoleInfo(); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetFastStreamInfo_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetFastStreamInfo_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetFastStreamInfo_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + GetServerPtr()->audioPolicyService_.audioConfigManager_.OnFastFormatParsed(AudioSampleFormat::SAMPLE_S32LE); + auto res = GetServerPtr()->audioPolicyService_.GetFastStreamInfo(); + ASSERT_EQ(AudioSampleFormat::SAMPLE_S32LE, res.format); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetFastStreamInfo_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetFastStreamInfo_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetFastStreamInfo_002 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + auto res = GetServerPtr()->audioPolicyService_.GetFastStreamInfo(); + ASSERT_NE(AudioSampleFormat::SAMPLE_S16LE, res.format); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetActiveOutputDeviceDescriptor_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetActiveOutputDeviceDescriptor_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetActiveOutputDeviceDescriptor_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + auto res = GetServerPtr()->audioPolicyService_.GetActiveOutputDeviceDescriptor(); + ASSERT_NE(nullptr, res); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: OnMicrophoneBlockedUpdate_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, OnMicrophoneBlockedUpdate_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest OnMicrophoneBlockedUpdate_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + GetServerPtr()->audioPolicyService_.OnMicrophoneBlockedUpdate(DeviceType::DEVICE_TYPE_EARPIECE, + DeviceBlockStatus::DEVICE_BLOCKED); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: OnMicrophoneBlockedUpdate_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, OnMicrophoneBlockedUpdate_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest OnMicrophoneBlockedUpdate_002 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + GetServerPtr()->audioPolicyService_.OnMicrophoneBlockedUpdate(DeviceType::DEVICE_TYPE_NONE, + DeviceBlockStatus::DEVICE_BLOCKED); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetAllSinkInputs_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetAllSinkInputs_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetAllSinkInputs_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + std::vector sinkInputs; + GetServerPtr()->audioPolicyService_.GetAllSinkInputs(sinkInputs); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SubscribeSafeVolumeEvent_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SubscribeSafeVolumeEvent_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SubscribeSafeVolumeEvent_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + GetServerPtr()->audioPolicyService_.SubscribeSafeVolumeEvent(); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetAvailableDeviceChangeCallback_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetAvailableDeviceChangeCallback_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SetAvailableDeviceChangeCallback_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + int32_t clientId = 0; + const sptr object = new RemoteObjectTestStub(); + int32_t ret = GetServerPtr()->audioPolicyService_.SetAvailableDeviceChangeCallback(clientId, + AudioDeviceUsage::MEDIA_INPUT_DEVICES, object, true); + ASSERT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetAvailableDeviceChangeCallback_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetAvailableDeviceChangeCallback_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SetAvailableDeviceChangeCallback_002 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + int32_t clientId = 0; + const sptr object = nullptr; + int32_t ret = GetServerPtr()->audioPolicyService_.SetAvailableDeviceChangeCallback(clientId, + AudioDeviceUsage::MEDIA_INPUT_DEVICES, object, true); + ASSERT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetQueryClientTypeCallback_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetQueryClientTypeCallback_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SetQueryClientTypeCallback_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + const sptr object = new RemoteObjectTestStub(); + int32_t ret = GetServerPtr()->audioPolicyService_.SetQueryClientTypeCallback(object); + ASSERT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateDescWhenNoBTPermission_001 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP, DeviceRole::OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + + GetServerPtr()->audioPolicyService_.UpdateDescWhenNoBTPermission(devices); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateDescWhenNoBTPermission_002 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, DeviceRole::OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + + GetServerPtr()->audioPolicyService_.UpdateDescWhenNoBTPermission(devices); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission_003 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission_003, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateDescWhenNoBTPermission_003 start"); + ASSERT_NE(nullptr, GetServerPtr()); + GetPermission(); + std::vector> devices; + std::shared_ptr desc; + devices.push_back(desc); + + GetServerPtr()->audioPolicyService_.UpdateDescWhenNoBTPermission(devices); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: UpdateCapturerInfoWhenNoPermission_001 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateCapturerInfoWhenNoPermission_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateCapturerInfoWhenNoPermission_001 start"); + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO); + shared_ptr captureChangeInfo1 = make_shared(); + captureChangeInfo1->clientUID = 5000; + captureChangeInfo1->createrUID = 1001; + captureChangeInfo1->sessionId = 2001; + captureChangeInfo1->inputDeviceInfo = inputDeviceInfo; + + shared_ptr captureChangeInfo2 = make_shared(); + captureChangeInfo2->clientUID = 1001; + captureChangeInfo2->createrUID = 1001; + captureChangeInfo2->sessionId = 2001; + captureChangeInfo2->inputDeviceInfo = inputDeviceInfo; + + std::vector> audioCapturerChangeInfos; + audioCapturerChangeInfos.push_back(move(captureChangeInfo1)); + audioCapturerChangeInfos.push_back(move(captureChangeInfo2)); + bool hasBTPermission = false; + bool hasSystemPermission = false; + + int32_t ret = server->audioPolicyService_.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos, hasBTPermission, + hasSystemPermission); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: UpdateCapturerInfoWhenNoPermission_002 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateCapturerInfoWhenNoPermission_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateCapturerInfoWhenNoPermission_002 start"); + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::AUDIO_DEVICE_DESCRIPTOR); + shared_ptr captureChangeInfo = make_shared(); + captureChangeInfo->clientUID = 5000; + captureChangeInfo->createrUID = 1001; + captureChangeInfo->sessionId = 2001; + captureChangeInfo->inputDeviceInfo = inputDeviceInfo; + + std::vector> audioCapturerChangeInfos; + audioCapturerChangeInfos.push_back(move(captureChangeInfo)); + bool hasBTPermission = true; + bool hasSystemPermission = true; + + int32_t ret = server->audioPolicyService_.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos, hasBTPermission, + hasSystemPermission); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetPreferredOutputStreamType_002 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetPreferredOutputStreamType_002, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server) ; + + AudioRendererInfo rendererInfo; + rendererInfo.streamUsage = STREAM_USAGE_MAX ; + std::string bundleName ; + + int32_t ret = server->audioPolicyService_.GetPreferredOutputStreamType(rendererInfo, bundleName); + EXPECT_EQ(ret, AUDIO_FLAG_NORMAL); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetPreferredOutputStreamType_004 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetPreferredOutputStreamType_004, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server) ; + + AudioRendererInfo rendererInfo; + rendererInfo.rendererFlags = AUDIO_FLAG_VOIP_FAST; + std::string bundleName ; + auto& sceneManager = AudioSceneManager::GetInstance(); + sceneManager.SetAudioScenePre(AUDIO_SCENE_PHONE_CALL, 1, 1); + + int32_t ret = server->audioPolicyService_.GetPreferredOutputStreamType(rendererInfo, bundleName); + EXPECT_EQ(ret, AUDIO_FLAG_NORMAL); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetHardwareOutputSamplingRate_001 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetHardwareOutputSamplingRate_001, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + std::shared_ptr desc = nullptr; + int32_t ret = server->audioPolicyService_.GetHardwareOutputSamplingRate(desc); + EXPECT_EQ(ret, -1); + + desc = std::make_shared(); + desc->deviceRole_ = DeviceRole::DEVICE_ROLE_NONE; + ret = server->audioPolicyService_.GetHardwareOutputSamplingRate(desc); + EXPECT_EQ(ret, -1); + + desc->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + ret = server->audioPolicyService_.GetHardwareOutputSamplingRate(desc); + EXPECT_NE(ret, 48000); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetProcessDeviceInfo_001 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetProcessDeviceInfo_001, TestSize.Level1) +{ + auto &policyService = AudioPolicyService::GetAudioPolicyService(); + auto config = AudioProcessConfig(); + config.rendererInfo.rendererFlags = AUDIO_FLAG_VOIP_DIRECT; + config.rendererInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT; + config.capturerInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT; + bool lockFlag = false; + auto deviceInfo = AudioDeviceDescriptor(); + int32_t ret = 0; + + config.audioMode = AUDIO_MODE_PLAYBACK; + config.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + config.rendererInfo.streamUsage = STREAM_USAGE_VOICE_MESSAGE; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + config.audioMode = AUDIO_MODE_RECORD; + config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_first_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_first_unit_test.cpp index 9c21236398ebd82b759af4944c162de5e56e8f83..5747f40f1c2714a7e08dd736e132053e63b5ee13 100644 --- a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_first_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_first_unit_test.cpp @@ -296,19 +296,10 @@ HWTEST_F(AudioPolicyServiceUnitTest, AudioPolicyServiceTest_001, TestSize.Level1 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.hasModulesLoaded = true; GetServerPtr()->audioPolicyService_.OnPnpDeviceStatusUpdated(audioDeviceDescriptor, isConnected); } - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); + GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForA2dpDeviceOut(); GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->GetA2dpOffloadCodecAndSendToDsp(); GetServerPtr()->audioPolicyService_.audioMicrophoneDescriptor_.UpdateAudioCapturerMicrophoneDescriptor( deviceType); - for (const auto& flag : flags) { - AUDIO_INFO_LOG("AudioPolicyServiceTest_001 flag:%{public}d", static_cast(flag)); - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceInOffload(flag); - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceOutOffload(flag); - } - for (const auto& pipeType : pipeTypes) { - AUDIO_INFO_LOG("AudioPolicyServiceTest_001 pipeType:%{public}d", static_cast(pipeType)); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.MoveToNewPipeInner(TEST_SESSIONID, pipeType); - } // AccountTest GetServerPtr()->audioPolicyService_.NotifyAccountsChanged(TEST_SESSIONID); // SafeVolumeTest @@ -334,7 +325,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, AudioPolicyServiceTest_002, TestSize.Level1 audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; audioDeviceDescriptor->deviceRole_ = DeviceRole::OUTPUT_DEVICE; GetServerPtr()->audioPolicyService_.audioConnectedDevice_.connectedDevices_.push_back(audioDeviceDescriptor); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.isOffloadAvailable_ = true; for (const auto& preferredType : preferredTypes) { AUDIO_INFO_LOG("AudioPolicyServiceTest_002 preferredType:%{public}d", static_cast(preferredType)); @@ -349,47 +339,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, AudioPolicyServiceTest_002, TestSize.Level1 } } -/** -* @tc.name : Test AudioPolicyService. -* @tc.number: AudioPolicyServiceTest_003 -* @tc.desc : Test AudioPolicyService interfaces. -*/ -HWTEST_F(AudioPolicyServiceUnitTest, AudioPolicyServiceTest_003, TestSize.Level1) -{ - AUDIO_INFO_LOG("AudioPolicyServiceUnitTest AudioPolicyServiceTest_003 start"); - ASSERT_NE(nullptr, GetServerPtr()); - // set offload support on for covery - GetServerPtr()->audioPolicyService_.audioOffloadStream_.isOffloadAvailable_ = true; - for (const auto& deviceType : deviceTypes) { - AUDIO_ERR_LOG("AudioPolicyServiceTest_003 deviceType:%{public}d, TEST_SESSIONID:%{public}d", - static_cast(deviceType), TEST_SESSIONID); - for (const auto& audioStreamType : audioStreamTypes) { - AUDIO_ERR_LOG("AudioPolicyServiceTest_003 streamType:%{public}d", static_cast(audioStreamType)); - GetServerPtr()->audioPolicyManager_.GetSystemVolumeDb(audioStreamType); - } - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->GetVolumeGroupType(deviceType); - int32_t streamId = 1; - float volume = 0.1f; - GetServerPtr()->streamCollector_.SetLowPowerVolume(streamId, volume); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.SetOffloadMode(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.ResetOffloadMode(TEST_SESSIONID); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.RemoteOffloadStreamRelease(TEST_SESSIONID); - GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.GetOffloadAvailableFromXml(); - int32_t uid = getuid(); - for (const auto& isMute : isMutes) { - AUDIO_ERR_LOG("AudioPolicyServiceTest_003 isMute:%{public}d", static_cast(isMute)); - GetServerPtr()->audioPolicyService_.SetSourceOutputStreamMute(uid, isMute); - } - std::string networkId = REMOTE_NETWORK_ID; - AudioVolumeType volumeType =AudioVolumeType::STREAM_MEDIA; - int32_t groupId = 0; - std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId) + ";AUDIO_VOLUME_TYPE=" - + std::to_string(volumeType) + ";"; - std::string value = std::to_string(volume); - } -} - /** * @tc.name : Test AudioPolicyService. * @tc.number: AudioPolicyServiceTest_004 @@ -405,7 +354,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, AudioPolicyServiceTest_004, TestSize.Level1 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr); sptr audioRendererFilter = new AudioRendererFilter(); // set offload support on for covery - GetServerPtr()->audioPolicyService_.audioOffloadStream_.isOffloadAvailable_ = true; for (const auto& deviceType : deviceTypes) { AUDIO_ERR_LOG("AudioPolicyServiceTest_004 deviceType:%{public}d, TEST_SESSIONID:%{public}d", static_cast(deviceType), TEST_SESSIONID); @@ -571,7 +519,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, GetSelectedDeviceInfo_001, TestSize.Level1) audioDeviceDescriptor->networkId_ = REMOTE_NETWORK_ID; GetServerPtr()->audioPolicyService_.audioConnectedDevice_.connectedDevices_.push_back(audioDeviceDescriptor); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.isOffloadAvailable_ = true; GetServerPtr()->audioPolicyService_.audioRouteMap_.routerMap_[ROUTER_MAP_ID1] = std::pair(LOCAL_NETWORK_ID, (G_UNKNOWN_PID - 1)); @@ -602,39 +549,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, GetSelectedDeviceInfo_001, TestSize.Level1) GetServerPtr()->audioPolicyService_.GetSelectedDeviceInfo(ROUTER_MAP_ID6, G_UNKNOWN_PID, STREAM_MUSIC); } -/** -* @tc.name : Test CheckActiveOutputDeviceSupportOffload. -* @tc.number: CheckActiveOutputDeviceSupportOffload_001 -* @tc.desc : Test AudioPolicyService interfaces. -*/ -HWTEST_F(AudioPolicyServiceUnitTest, CheckActiveOutputDeviceSupportOffload_001, TestSize.Level1) -{ - AUDIO_INFO_LOG("AudioPolicyServiceUnitTest CheckActiveOutputDeviceSupportOffload_001 start"); - ASSERT_NE(nullptr, GetServerPtr()); - bool ret = false; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ - = std::string(LOCAL_NETWORK_ID) + "xyz"; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_REMOTE_CAST; - ret = GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(false, ret); - - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ - = std::string(LOCAL_NETWORK_ID) + "xyz"; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - ret = GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(false, ret); - - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_REMOTE_CAST; - ret = GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(false, ret); - - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - ret = GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - EXPECT_EQ(true, ret); -} - /** * @tc.name : Test SetSourceOutputStreamMute. * @tc.number: SetSourceOutputStreamMute_001 @@ -1446,79 +1360,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, HasLowLatencyCapability_001, TestSize.Level EXPECT_EQ(false, ret); } -#ifdef TEMP_DISABLE -/** -* @tc.name : Test HandleActiveDevice. -* @tc.number: HandleActiveDevice_001 -* @tc.desc : Test AudioPolicyService interfaces. -*/ -HWTEST_F(AudioPolicyServiceUnitTest, HandleActiveDevice_001, TestSize.Level1) -{ - AUDIO_INFO_LOG("AudioPolicyServiceUnitTest HandleActiveDevice start"); - ASSERT_NE(nullptr, GetServerPtr()); - int32_t ret = SUCCESS; - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_NONE); - EXPECT_EQ(ERR_OPERATION_FAILED, ret); - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_INVALID); - EXPECT_EQ(ERR_OPERATION_FAILED, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_EARPIECE); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_SPEAKER); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_WIRED_HEADSET); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice( - DEVICE_TYPE_WIRED_HEADPHONES); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_BLUETOOTH_SCO); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_BLUETOOTH_A2DP); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_MIC); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_WAKEUP); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_USB_HEADSET); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_DP); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_REMOTE_CAST); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_FILE_SINK); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_FILE_SOURCE); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_EXTERN_CABLE); - EXPECT_EQ(ERR_OPERATION_FAILED, ret); - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_DEFAULT); - EXPECT_EQ(ERR_OPERATION_FAILED, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_USB_ARM_HEADSET); - EXPECT_EQ(SUCCESS, ret); - - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_MAX); - EXPECT_EQ(ERR_OPERATION_FAILED, ret); - - GetServerPtr()->audioPolicyService_.audioConfigManager_.OnUpdateRouteSupport(false); - ret = GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleActiveDevice(DEVICE_TYPE_MIC); - EXPECT_EQ(SUCCESS, ret); -} -#endif - /** * @tc.name : Test HandleLocalDeviceConnected. * @tc.number: HandleLocalDeviceConnected_001 @@ -2444,30 +2285,6 @@ HWTEST_F(AudioPolicyServiceUnitTest, SetSystemVolumeLevel_001, TestSize.Level1) } } -/** -* @tc.name : Test HandlePowerStateChanged. -* @tc.number: HandlePowerStateChanged_001 -* @tc.desc : Test AudioPolicyService interfaces. -*/ -HWTEST_F(AudioPolicyServiceUnitTest, HandlePowerStateChanged_001, TestSize.Level1) -{ - AUDIO_INFO_LOG("AudioPolicyServiceUnitTest HandlePowerStateChanged_001 start"); - ASSERT_NE(nullptr, GetServerPtr()); - - GetServerPtr()->audioPolicyService_.audioOffloadStream_.offloadSessionID_.reset(); - - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ = REMOTE_NETWORK_ID; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_REMOTE_CAST; - - PowerMgr::PowerState state = PowerMgr::PowerState::STAND_BY; - GetServerPtr()->audioOffloadStream_.HandlePowerStateChanged(state); - - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID; - GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; - GetServerPtr()->audioPolicyService_.audioOffloadStream_.offloadSessionID_ = TEST_SESSIONID; - GetServerPtr()->audioOffloadStream_.HandlePowerStateChanged(state); -} - /** * @tc.name : Test GetSystemVolumeInDb. * @tc.number: GetSystemVolumeInDb_001 diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_second_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_second_unit_test.cpp index 814c72df7f5fbfb81ae447236af2a44adbf57fb3..709685ac6f7f97fae31ba425b6ebc33d5f4ce581 100644 --- a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_second_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_second_unit_test.cpp @@ -155,19 +155,6 @@ HWTEST_F(AudioPolicyServiceExtUnitTest, CheckAudioSessionStrategy_001, TestSize. EXPECT_EQ(ret, false); } -/** - * @tc.name : Test HandleA2dpDeviceInOffload. - * @tc.number: HandleA2dpDeviceInOffload_001 - * @tc.desc : Test HandleA2dpDeviceInOffload interfaces. - */ -HWTEST_F(AudioPolicyServiceExtUnitTest, HandleA2dpDeviceInOffload_001, TestSize.Level1) -{ - auto server = GetServerUtil::GetServerPtr(); - BluetoothOffloadState a2dpOffloadFlag = A2DP_NOT_OFFLOAD; - int32_t ret = server->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceInOffload(a2dpOffloadFlag); - EXPECT_EQ(ret, SUCCESS); -} - /** * @tc.name : Test WriteAllDeviceSysEvents. * @tc.number: WriteAllDeviceSysEvents_001 @@ -957,44 +944,6 @@ HWTEST_F(AudioPolicyServiceExtUnitTest, TriggerAvailableDeviceChangedCallback_00 EXPECT_NE(server->audioPolicyService_.audioPolicyServerHandler_, nullptr); } -/** - * @tc.name : Test OffloadStartPlaying. - * @tc.number: OffloadStartPlaying_001 - * @tc.desc : Test OffloadStartPlaying interfaces. - */ -HWTEST_F(AudioPolicyServiceExtUnitTest, OffloadStartPlaying_001, TestSize.Level1) -{ - auto server = GetServerUtil::GetServerPtr(); - std::vector sessionIds = {0}; - int32_t ret; - - ret = server->audioPolicyService_.OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, SUCCESS); - - sessionIds.clear(); - ret = server->audioPolicyService_.OffloadStartPlaying(sessionIds); - EXPECT_EQ(ret, SUCCESS); -} - -/** - * @tc.name : Test OffloadStopPlaying. - * @tc.number: OffloadStopPlaying_001 - * @tc.desc : Test OffloadStopPlaying interfaces. - */ -HWTEST_F(AudioPolicyServiceExtUnitTest, OffloadStopPlaying_001, TestSize.Level1) -{ - auto server = GetServerUtil::GetServerPtr(); - std::vector sessionIds = {0}; - int32_t ret; - - ret = server->audioPolicyService_.OffloadStopPlaying(sessionIds); - EXPECT_EQ(ret, SUCCESS); - - sessionIds.clear(); - ret = server->audioPolicyService_.OffloadStopPlaying(sessionIds); - EXPECT_EQ(ret, SUCCESS); -} - /** * @tc.name : Test OffloadGetRenderPosition. * @tc.number: OffloadGetRenderPosition_001 diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_third_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_third_unit_test.cpp index 30b8d1252124e40f1297baa96c1bdef71696e840..843c8bd2376bc0231046943836e7a153d366d44c 100644 --- a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_third_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_third_unit_test.cpp @@ -53,6 +53,119 @@ public: bool Marshalling(Parcel &parcel) const override { return true; }; }; +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetAudioEnhanceProperty_002 + * @tc.desc : Test GetAudioEnhanceProperty interfaces. + */ +HWTEST_F(AudioPolicyServiceThirdUnitTest, GetAudioEnhanceProperty_002, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + AudioEffectPropertyArrayV3 propertyArray; + AudioEffectPropertyV3 effectProperty; + effectProperty.flag = CAPTURE_EFFECT_FLAG; + propertyArray.property.push_back(effectProperty); + + int32_t ret = server->audioPolicyService_.GetAudioEnhanceProperty(propertyArray); + EXPECT_NE(ret, AudioServerProxy::GetInstance().GetAudioEffectPropertyProxy(propertyArray)); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetAudioEnhanceProperty_003 + * @tc.desc : Test GetAudioEnhanceProperty interfaces. + */ +HWTEST_F(AudioPolicyServiceThirdUnitTest, GetAudioEnhanceProperty_003, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + AudioEffectPropertyArrayV3 propertyArray; + AudioEffectPropertyV3 effectProperty; + effectProperty.flag = RENDER_EFFECT_FLAG; + propertyArray.property.push_back(effectProperty); + + int32_t ret = server->audioPolicyService_.GetAudioEnhanceProperty(propertyArray); + EXPECT_NE(ret, AudioServerProxy::GetInstance().GetAudioEffectPropertyProxy(propertyArray)); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetProcessDeviceInfo_001 + * @tc.desc : Test GetProcessDeviceInfo interfaces. + */ +HWTEST_F(AudioPolicyServiceThirdUnitTest, GetProcessDeviceInfo_001, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + AudioProcessConfig config; + config.audioMode = AUDIO_MODE_PLAYBACK; + AudioDeviceDescriptor deviceInfo; + bool lockFlag = false; + + config.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION; + int32_t ret = server->audioPolicyService_.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + EXPECT_EQ(deviceInfo.deviceRole_, OUTPUT_DEVICE); + EXPECT_EQ(ret, ERROR); + + config.rendererInfo.streamUsage = STREAM_USAGE_MUSIC; + ret = server->audioPolicyService_.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + EXPECT_EQ(deviceInfo.deviceRole_, OUTPUT_DEVICE); + EXPECT_EQ(ret, SUCCESS); + + config.audioMode = AUDIO_MODE_RECORD; + config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION; + ret = server->audioPolicyService_.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + EXPECT_EQ(deviceInfo.deviceRole_, INPUT_DEVICE); + EXPECT_EQ(ret, ERROR); + + config.audioMode = AUDIO_MODE_RECORD; + config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL; + ret = server->audioPolicyService_.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + EXPECT_EQ(deviceInfo.deviceRole_, INPUT_DEVICE); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: UpdateCapturerInfoWhenNoPermission_001 + * @tc.desc : Test UpdateCapturerInfoWhenNoPermission interfaces. + */ +HWTEST_F(AudioPolicyServiceThirdUnitTest, UpdateCapturerInfoWhenNoPermission_001, TestSize.Level1) +{ + shared_ptr audioCapturerChangeInfos = make_shared(); + bool hasSystemPermission = true; + audioCapturerChangeInfos->clientUID = 1; + audioCapturerChangeInfos->capturerState = CAPTURER_NEW; + + AudioCoreService::UpdateCapturerInfoWhenNoPermission(audioCapturerChangeInfos, hasSystemPermission); + EXPECT_NE(audioCapturerChangeInfos->clientUID, 0); + EXPECT_NE(audioCapturerChangeInfos->capturerState, CAPTURER_INVALID); + + hasSystemPermission = false; + AudioCoreService::UpdateCapturerInfoWhenNoPermission(audioCapturerChangeInfos, hasSystemPermission); + EXPECT_EQ(audioCapturerChangeInfos->clientUID, 0); + EXPECT_EQ(audioCapturerChangeInfos->capturerState, CAPTURER_INVALID); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: SetQueryClientTypeCallback_001 + * @tc.desc : Test SetQueryClientTypeCallback interfaces. + */ +HWTEST_F(AudioPolicyServiceThirdUnitTest, SetQueryClientTypeCallback_001, TestSize.Level1) +{ + auto server = GetServerPtr(); + ASSERT_NE(nullptr, server); + + sptr object = nullptr; + int32_t ret = server->audioPolicyService_.SetQueryClientTypeCallback(object); + EXPECT_EQ(ret, SUCCESS); +} + /** * @tc.name : Test AudioPolicyService. * @tc.number: GetOffloadStatusDump_001 @@ -1023,8 +1136,6 @@ HWTEST_F(AudioPolicyServiceThirdUnitTest, SetVirtualCall_001, TestSize.Level1) bool isVirtual = false; int32_t ret = server->audioDeviceCommon_.SetVirtualCall(0, isVirtual); EXPECT_EQ(ret, SUCCESS); - ret = server->audioDeviceCommon_.SetVirtualCall(5523, isVirtual); /* 5523: call manager */ - EXPECT_EQ(ret, SUCCESS); } /** @@ -1377,45 +1488,6 @@ HWTEST_F(AudioPolicyServiceThirdUnitTest, InitSharedVolume_001, TestSize.Level1) EXPECT_EQ(ret, 0); } -/** - * @tc.name : Test MoveToNewPipe. - * @tc.number: MoveToNewPipe_001 - * @tc.desc : Test AudioPolicyService interfaces. - */ -HWTEST_F(AudioPolicyServiceThirdUnitTest, MoveToNewPipe_001, TestSize.Level1) -{ - auto server = GetServerPtr(); - ASSERT_NE(nullptr, server); - - uint32_t sessionId = 0; - AudioPipeType pipeType = PIPE_TYPE_UNKNOWN; - int32_t ret = server->audioOffloadStream_.MoveToNewPipe(sessionId, pipeType); - EXPECT_NE(ret, 0); -} - -/** - * @tc.name : Test DynamicUnloadModule. - * @tc.number: DynamicUnloadModule_001 - * @tc.desc : Test AudioPolicyService interfaces. - */ -HWTEST_F(AudioPolicyServiceThirdUnitTest, DynamicUnloadModule_001, TestSize.Level1) -{ - auto server = GetServerPtr(); - ASSERT_NE(nullptr, server); - - AudioPipeType pipeType = PIPE_TYPE_OFFLOAD; - int32_t ret = server->audioPolicyService_.DynamicUnloadModule(pipeType); - EXPECT_EQ(ret, SUCCESS); - - pipeType = PIPE_TYPE_MULTICHANNEL; - ret = server->audioPolicyService_.DynamicUnloadModule(pipeType); - EXPECT_NE(ret, SUCCESS); - - pipeType = PIPE_TYPE_DIRECT_VOIP; - ret = server->audioPolicyService_.DynamicUnloadModule(pipeType); - EXPECT_EQ(ret, SUCCESS); -} - /** * @tc.name : Test GetMaxRendererInstances. * @tc.number: GetMaxRendererInstances_001 diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_thirdext_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_thirdext_unit_test.cpp index b934fbce54e15d3a9bf65a8702aa81b6cd7158e3..adb0bf4a432d3dd607e400e1a9ad493eb3f66ce4 100644 --- a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_thirdext_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_thirdext_unit_test.cpp @@ -139,13 +139,13 @@ HWTEST_F(AudioPolicyServiceFourthUnitTest, LoadHdiEffectModel_001, TestSize.Leve } /** -* @tc.name : Test OnReceiveBluetoothEvent. -* @tc.number: OnReceiveBluetoothEvent_001 +* @tc.name : Test OnReceiveUpdateDeviceNameEvent. +* @tc.number: OnReceiveUpdateDeviceNameEvent_001 * @tc.desc : Test AudioPolicyService interfaces. */ -HWTEST_F(AudioPolicyServiceFourthUnitTest, OnReceiveBluetoothEvent_001, TestSize.Level1) +HWTEST_F(AudioPolicyServiceFourthUnitTest, OnReceiveUpdateDeviceNameEvent_001, TestSize.Level1) { - AUDIO_INFO_LOG("AudioPolicyServiceFourthUnitTest OnReceiveBluetoothEvent_001 start"); + AUDIO_INFO_LOG("AudioPolicyServiceFourthUnitTest OnReceiveUpdateDeviceNameEvent_001 start"); ASSERT_NE(nullptr, GetServerUtil::GetServerPtr()); const std::string macAddress = "11-11-11-11-11-11"; @@ -240,21 +240,6 @@ HWTEST_F(AudioPolicyServiceFourthUnitTest, IsA2dpOffloadConnecting_003, TestSize EXPECT_FALSE(ret); } -/** -* @tc.name : Test CheckSpatializationAndEffectState. -* @tc.number: CheckSpatializationAndEffectState_001 -* @tc.desc : Test AudioPolicyServic interfaces. -*/ -HWTEST_F(AudioPolicyServiceFourthUnitTest, CheckSpatializationAndEffectState_001, TestSize.Level1) -{ - AUDIO_INFO_LOG("AudioPolicyServiceFourthUnitTest CheckSpatializationAndEffectState_001 start"); - auto server = GetServerUtil::GetServerPtr(); - EXPECT_NE(nullptr, server); - - bool ret = server->audioPolicyService_.audioOffloadStream_.CheckSpatializationAndEffectState(); - EXPECT_FALSE(ret); -} - /** * @tc.name : Test UpdateRoute. * @tc.number: UpdateRoute_001 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 cd408e3e971e71f474abb0f41b46ab22cb89fa5a..848b6d4a63ba44c4716029806a2dd30379e759f1 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 @@ -23,6 +23,9 @@ #include using namespace testing::ext; +static constexpr int32_t CLIENT_UID_TYPE_NONE = 1; +static constexpr int32_t CLIENT_UID_TYPE_EARPIECE = 2; + namespace OHOS { namespace AudioStandard { @@ -217,10 +220,20 @@ public: return callCaptureRet_; } - std::vector> GetRingRenderDevices(StreamUsage, int32_t) override + std::vector> GetRingRenderDevices(StreamUsage, int32_t clientUID) override { - static const std::vector> emptyVector; - return emptyVector; + std::vector> descs; + auto desc = std::make_shared(); + + if (clientUID == CLIENT_UID_TYPE_NONE) { + desc->deviceType_ = DEVICE_TYPE_NONE; + descs.push_back(desc); + } else if (clientUID == CLIENT_UID_TYPE_EARPIECE) { + desc->deviceType_ = DEVICE_TYPE_EARPIECE; + descs.push_back(desc); + } + + return descs; } std::shared_ptr GetRecordCaptureDevice(SourceType, int32_t, const uint32_t) override @@ -238,7 +251,36 @@ public: return routerType_; } }; - + +/** + * @tc.name : Test FetchRingRenderDevices. + * @tc.number: FetchRingRenderDevices_002 + * @tc.desc : Test FetchRingRenderDevices interface. + */ +HWTEST(AudioRouterCenterUnitTest, FetchRingRenderDevices_002, TestSize.Level1) +{ + AudioRouterCenter center; + auto invalidDesc = std::make_shared(); + invalidDesc->deviceType_ = DEVICE_TYPE_NONE; + center.ringRenderRouters_.emplace_back( + std::make_unique(ROUTER_TYPE_DEFAULT, nullptr, nullptr, invalidDesc)); + + StreamUsage streamUsage = STREAM_USAGE_RINGTONE; + int32_t clientUID = 0; + RouterType routerType; + auto result = center.FetchRingRenderDevices(streamUsage, clientUID, routerType); + EXPECT_EQ(result.front()->deviceType_, DEVICE_TYPE_NONE); + + clientUID = 1; + result = center.FetchRingRenderDevices(streamUsage, clientUID, routerType); + EXPECT_EQ(result.front()->deviceType_, DEVICE_TYPE_NONE); + + clientUID = 2; + result = center.FetchRingRenderDevices(streamUsage, clientUID, routerType); + EXPECT_NE(result.front(), nullptr); + EXPECT_EQ(result.front()->deviceType_, DEVICE_TYPE_EARPIECE); +} + /** * @tc.name : Test FetchMediaRenderDevice. * @tc.number: FetchMediaRenderDevice_001 diff --git a/services/audio_policy/test/unittest/audio_router_center_unit_test/src/default_router_unit_test.cpp b/services/audio_policy/test/unittest/audio_router_center_unit_test/src/default_router_unit_test.cpp index 83304348acf50043ba8bea1f01167731f7aa5ee9..d9cc169095db93e9d4e783a50c03325f97dc6862 100644 --- a/services/audio_policy/test/unittest/audio_router_center_unit_test/src/default_router_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_router_center_unit_test/src/default_router_unit_test.cpp @@ -220,6 +220,26 @@ HWTEST(AudioRouterCenterUnitTest, CockpitPhoneRouter_GetRingRenderDevices_001, T cockpitPhoneRouter.GetRingRenderDevices(streamUsage, clientUID); EXPECT_TRUE(descs.empty()); } + +/** + * @tc.name : Test CockpitPhoneRouter_GetBTCarDevices. + * @tc.number: CockpitPhoneRouter_GetBTCarDevices_001 + * @tc.desc : Test CockpitPhoneRouter_GetBTCarDevices interface. + */ +HWTEST(AudioRouterCenterUnitTest, CockpitPhoneRouter_GetBTCarDevices_001, TestSize.Level4) +{ + StreamUsage streamUsage = STREAM_USAGE_ALARM; + int32_t clientUID = 1000; + CockpitPhoneRouter cockpitPhoneRouter; + shared_ptr desc1 = nullptr; + shared_ptr desc2 = make_shared(); + desc2->deviceCategory_ = BT_CAR; + shared_ptr desc3 = make_shared(); + desc2->deviceCategory_ = BT_SOUNDBOX; + AudioDeviceManager::GetAudioDeviceManager().commRenderPublicDevices_ = { desc1, desc2, desc3 }; + shared_ptr desc = cockpitPhoneRouter.GetCallRenderDevice(streamUsage, clientUID); + EXPECT_NE(desc, nullptr); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/include/audio_collaborative_service_unit_test.h b/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/include/audio_collaborative_service_unit_test.h index 182a4a99d7bc0f6ae64f31969af35f6a741167a7..f8799f356eccb168aa43245e443435b9c2326e99 100644 --- a/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/include/audio_collaborative_service_unit_test.h +++ b/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/include/audio_collaborative_service_unit_test.h @@ -38,4 +38,4 @@ protected: }; } // namespace AudioStandard } // namespace OHOS -#endif //AUDIO_SPATIALIZATION_SERVICE_UNIT_TEST_H \ No newline at end of file +#endif // AUDIO_SPATIALIZATION_SERVICE_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/src/audio_collaborative_service_unit_test.cpp b/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/src/audio_collaborative_service_unit_test.cpp index 9653a0b98c5f9d8654598e9c1b0419962392c4b4..ab31abb021baf1f84c6c63b42ae58c998d874b14 100644 --- a/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/src/audio_collaborative_service_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_spatialization_service_unit_test/src/audio_collaborative_service_unit_test.cpp @@ -27,10 +27,12 @@ void AudioCollaborativeServiceUnitTest::TearDownTestCase(void) {} void AudioCollaborativeServiceUnitTest::SetUp(void) { audioCollaborativeServicePtr_ = std::make_unique(); + audioCollaborativeService_.isCollaborativePlaybackSupported_ = true; } void AudioCollaborativeServiceUnitTest::TearDown(void) { audioCollaborativeServicePtr_.reset(); + audioCollaborativeService_.addressToCollaborativeEnabledMap_.clear(); } static std::string testAddr1 = "address1"; static std::string testAddr2 = "address2"; @@ -49,8 +51,13 @@ static const std::string BLUETOOTH_EFFECT_CHAIN_NAME = "EFFECTCHAIN_COLLABORATIV */ HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_001, TestSize.Level0) { - bool isSupported = audioCollaborativeService_.IsCollaborativePlaybackSupported(); - EXPECT_EQ(isSupported, true); + std::vector applyVec; + EffectChain effectChain1(BLUETOOTH_EFFECT_CHAIN_NAME, applyVec, AUDIO_COLLABORATIVE_SERVICE_LABEL); + EffectChain effectChain2(BLUETOOTH_EFFECT_CHAIN_NAME, applyVec, TEST_LABEL); + EffectChain effectChain3(TEST_NAME, applyVec, TEST_LABEL); + std::vector effectChains = { effectChain1, effectChain2, effectChain3 }; + audioCollaborativeServicePtr_->Init(effectChains); + EXPECT_TRUE(audioCollaborativeServicePtr_->isCollaborativePlaybackSupported_); } /** @@ -101,6 +108,7 @@ HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_003, TestS * @tc.name : Test Su. * @tc.number: AudioSpatializationService_004 * @tc.desc : Test UpdateCurrentDevice. +* isCollaborativeStateEnabled_ should be updated when collaborative state for current device is changed. */ HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_004, TestSize.Level0) { @@ -117,51 +125,42 @@ HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_004, TestS EXPECT_EQ(ret, SUCCESS); ret = audioCollaborativeService_.SetCollaborativePlaybackEnabledForDevice(AudioDevice2, false); EXPECT_EQ(ret, SUCCESS); - audioCollaborativeService_.UpdateCurrentDevice(*AudioDevice1); audioCollaborativeService_.UpdateCurrentDevice(*AudioDevice2); + EXPECT_EQ(audioCollaborativeService_.isCollaborativeStateEnabled_, false); + audioCollaborativeService_.UpdateCurrentDevice(*AudioDevice1); + EXPECT_EQ(audioCollaborativeService_.isCollaborativeStateEnabled_, true); audioCollaborativeService_.UpdateCurrentDevice(*AudioDevice3); -} - -/** -* @tc.name : Test Su. -* @tc.number: AudioCollaborativeService_005 -* @tc.desc : Test Init. -*/ -HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_005, TestSize.Level0) -{ - std::vector applyVec; - EffectChain effectChain1(BLUETOOTH_EFFECT_CHAIN_NAME, applyVec, AUDIO_COLLABORATIVE_SERVICE_LABEL); - EffectChain effectChain2(BLUETOOTH_EFFECT_CHAIN_NAME, applyVec, TEST_LABEL); - EffectChain effectChain3(TEST_NAME, applyVec, TEST_LABEL); - std::vector effectChains = { effectChain1, effectChain2, effectChain3 }; - audioCollaborativeServicePtr_->Init(effectChains); - EXPECT_TRUE(audioCollaborativeServicePtr_->isCollaborativePlaybackSupported_); + EXPECT_EQ(audioCollaborativeService_.isCollaborativeStateEnabled_, false); } /** * @tc.name : Test Su. * @tc.number: AudioCollaborativeService_006 * @tc.desc : Test UpdateCurrentDevice. +* When device is in addressToCollaborativeEnabledMap_ and its type is changed, its collaborative state +* should be changed too.s */ -HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_006, TestSize.Level0) +HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_005, TestSize.Level0) { AudioDeviceDescriptor descriptor1; descriptor1.macAddress_ = TEST_MAC_ADDR; - descriptor1.deviceType_ = DEVICE_TYPE_EARPIECE; + descriptor1.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; AudioDeviceDescriptor descriptor2; - descriptor2.macAddress_ = EMPTY_MAC_ADDR; - descriptor2.deviceType_ = DEVICE_TYPE_EARPIECE; - audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_ - .insert(std::pair(TEST_MAC_ADDR, true)); + descriptor2.macAddress_ = testAddr1; + descriptor2.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_[TEST_MAC_ADDR] = COLLABORATIVE_OPENED; + descriptor1.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO; audioCollaborativeServicePtr_->UpdateCurrentDevice(descriptor1); - EXPECT_EQ(audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_.size(), 0); + EXPECT_EQ(audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_[TEST_MAC_ADDR], COLLABORATIVE_RESERVED); + descriptor1.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; audioCollaborativeServicePtr_->UpdateCurrentDevice(descriptor1); - EXPECT_EQ(audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_.size(), 1); + EXPECT_EQ(audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_[TEST_MAC_ADDR], COLLABORATIVE_OPENED); + // size of addressToCollaborativeEnabledMap_ should no be changed by UpdateCurrentDevice() audioCollaborativeServicePtr_->UpdateCurrentDevice(descriptor2); EXPECT_EQ(audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_.size(), 1); - descriptor1.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + descriptor1.deviceType_ = DEVICE_TYPE_SPEAKER; audioCollaborativeServicePtr_->UpdateCurrentDevice(descriptor2); EXPECT_EQ(audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_.size(), 1); } @@ -171,25 +170,32 @@ HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_006, TestS * @tc.number: AudioCollaborativeService_007 * @tc.desc : Test UpdateCollaborativeStateReal. */ -HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_007, TestSize.Level0) +HWTEST_F(AudioCollaborativeServiceUnitTest, AudioCollaborativeService_006, TestSize.Level0) { + // local device does not support collaborative service audioCollaborativeServicePtr_->isCollaborativePlaybackSupported_ = false; EXPECT_EQ(audioCollaborativeServicePtr_->UpdateCollaborativeStateReal(), ERROR); audioCollaborativeServicePtr_->isCollaborativePlaybackSupported_ = true; + // current device is not in addressToCollaborativeEnabledMap_ but collaborative state is true + audioCollaborativeServicePtr_->curDeviceAddress_ = testAddr1; audioCollaborativeServicePtr_->isCollaborativeStateEnabled_ = true; - audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_ - .insert(std::pair(TEST_MAC_ADDR, true)); - audioCollaborativeServicePtr_->curDeviceAddress_ = EMPTY_MAC_ADDR; - EXPECT_EQ(audioCollaborativeServicePtr_->UpdateCollaborativeStateReal(), - ERR_OPERATION_FAILED); + EXPECT_EQ(audioCollaborativeServicePtr_->UpdateCollaborativeStateReal(), ERR_OPERATION_FAILED); + // current device is not in addressToCollaborativeEnabledMap_ but collaborative state is false + audioCollaborativeServicePtr_->isCollaborativeStateEnabled_ = false; + EXPECT_EQ(audioCollaborativeServicePtr_->UpdateCollaborativeStateReal(), SUCCESS); + + // current device address is in addressToCollaborativeEnabledMap_ and collaborative state should be changed + audioCollaborativeServicePtr_->isCollaborativeStateEnabled_ = false; + audioCollaborativeServicePtr_->addressToCollaborativeEnabledMap_[TEST_MAC_ADDR] = COLLABORATIVE_OPENED; audioCollaborativeServicePtr_->curDeviceAddress_ = TEST_MAC_ADDR; EXPECT_EQ(audioCollaborativeServicePtr_->UpdateCollaborativeStateReal(), ERR_OPERATION_FAILED); + EXPECT_EQ(audioCollaborativeServicePtr_->GetRealCollaborativeState(), true); + // current device address is in addressToCollaborativeEnabledMap_ and collaborative state should not be changed audioCollaborativeServicePtr_->isCollaborativeStateEnabled_ = true; EXPECT_EQ(audioCollaborativeServicePtr_->UpdateCollaborativeStateReal(), SUCCESS); - EXPECT_EQ(audioCollaborativeServicePtr_->GetRealCollaborativeState(), true); } } // AudioStandard } // OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_stream_collector_unit_test/src/audio_stream_collector_unit_test.cpp b/services/audio_policy/test/unittest/audio_stream_collector_unit_test/src/audio_stream_collector_unit_test.cpp index 36075d509aa5c4cacf96749094accfc6502bc887..6e551e3c182787550550fd8fa1dbf181f4e2f5f6 100644 --- a/services/audio_policy/test/unittest/audio_stream_collector_unit_test/src/audio_stream_collector_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_stream_collector_unit_test/src/audio_stream_collector_unit_test.cpp @@ -42,6 +42,105 @@ void AudioStreamCollectorUnitTest::TearDown(void) {} #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__) +/** +* @tc.name : Test AudioStreamCollector. +* @tc.number: HandleKaraokeAppToBack_001 +* @tc.desc : Test HandleKaraokeAppToBack. +*/ +HWTEST_F(AudioStreamCollectorUnitTest, HandleKaraokeAppToBack_001, TestSize.Level1) +{ + AudioStreamCollector collector; + int32_t uid = 1001; + int32_t pid = 3001; + StreamUsage callStreamUsage = collector.GetLastestRunningCallStreamUsage(); + shared_ptr rendererChangeInfo = make_shared(); + + rendererChangeInfo->clientUID = 1001; + rendererChangeInfo->rendererInfo.isLoopback = true; + rendererChangeInfo->clientPid = 3001; + rendererChangeInfo->sessionId = 2001; + collector.audioRendererChangeInfos_.push_back(rendererChangeInfo); + + sptr object; + sptr listener = iface_cast(object); + std::shared_ptr callback = std::make_shared(listener); + collector.clientTracker_[rendererChangeInfo->sessionId] = callback; + + EXPECT_NO_THROW(collector.HandleKaraokeAppToBack(uid, pid)); + EXPECT_EQ(collector.audioRendererChangeInfos_[0]->clientUID, uid); + EXPECT_NE(collector.clientTracker_[rendererChangeInfo->sessionId], nullptr); + + collector.clientTracker_[rendererChangeInfo->sessionId] = nullptr; + + EXPECT_NO_THROW(collector.HandleKaraokeAppToBack(uid, pid)); + EXPECT_EQ(collector.audioRendererChangeInfos_[0]->clientUID, uid); + EXPECT_EQ(collector.clientTracker_[rendererChangeInfo->sessionId], nullptr); +} + +/** +* @tc.name : Test AudioStreamCollector. +* @tc.number: HandleKaraokeAppToBack_002 +* @tc.desc : Test HandleKaraokeAppToBack. +*/ +HWTEST_F(AudioStreamCollectorUnitTest, HandleKaraokeAppToBack_002, TestSize.Level1) +{ + AudioStreamCollector collector; + int32_t uid = 1001; + int32_t pid = 3001; + StreamUsage callStreamUsage = collector.GetLastestRunningCallStreamUsage(); + shared_ptr rendererChangeInfo = nullptr; + collector.audioRendererChangeInfos_.push_back(rendererChangeInfo); + + EXPECT_NO_THROW(collector.HandleKaraokeAppToBack(uid, pid)); + EXPECT_EQ(collector.audioRendererChangeInfos_[0], nullptr); + + collector.audioRendererChangeInfos_[0] = make_shared(); + collector.audioRendererChangeInfos_[0]->clientUID = 1002; + collector.audioRendererChangeInfos_[0]->rendererInfo.isLoopback = true; + collector.audioRendererChangeInfos_[0]->clientPid = 3001; + collector.audioRendererChangeInfos_[0]->sessionId = 2001; + EXPECT_NO_THROW(collector.HandleKaraokeAppToBack(uid, pid)); + EXPECT_EQ(collector.audioRendererChangeInfos_[0]->clientPid, pid); + EXPECT_NE(collector.audioRendererChangeInfos_[0]->clientUID, uid); + + collector.audioRendererChangeInfos_[0]->clientUID = 1001; + collector.audioRendererChangeInfos_[0]->clientPid = 3002; + EXPECT_NO_THROW(collector.HandleKaraokeAppToBack(uid, pid)); + EXPECT_NE(collector.audioRendererChangeInfos_[0]->clientPid, pid); + + collector.audioRendererChangeInfos_[0]->clientPid = 3001; + collector.audioRendererChangeInfos_[0]->rendererInfo.isLoopback = false; + EXPECT_NO_THROW(collector.HandleKaraokeAppToBack(uid, pid)); + EXPECT_FALSE(collector.audioRendererChangeInfos_[0]->rendererInfo.isLoopback); +} + +/** +* @tc.name : Test AudioStreamCollector. +* @tc.number: UpdateCapturerStreamInternal_001 +* @tc.desc : Test UpdateCapturerStreamInternal. +*/ +HWTEST_F(AudioStreamCollectorUnitTest, UpdateCapturerStreamInternal_001, TestSize.Level1) +{ + AudioStreamCollector collector; + AudioStreamChangeInfo streamChangeInfo; + streamChangeInfo.audioCapturerChangeInfo.clientUID = 1001; + streamChangeInfo.audioCapturerChangeInfo.sessionId = 2001; + streamChangeInfo.audioCapturerChangeInfo.capturerState = CapturerState::CAPTURER_RUNNING; + shared_ptr capturerChangeInfo = make_shared(); + + int32_t ret = collector.UpdateCapturerStreamInternal(streamChangeInfo); + EXPECT_EQ(ERROR, ret); + + capturerChangeInfo->clientUID = 1001; + capturerChangeInfo->createrUID = 1001; + capturerChangeInfo->sessionId = 2001; + capturerChangeInfo->capturerInfo.pipeType = PIPE_TYPE_MULTICHANNEL; + collector.audioCapturerChangeInfos_.push_back(move(capturerChangeInfo)); + + ret = collector.UpdateCapturerStreamInternal(streamChangeInfo); + EXPECT_EQ(SUCCESS, ret); +} + /** * @tc.name : Test AudioStreamCollector. * @tc.number: AudioStreamCollector_001 @@ -1134,6 +1233,28 @@ HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_040, TestSize.Level1 EXPECT_TRUE(ret); } + +/** +* @tc.name : Test AudioStreamCollector. +* @tc.number: AudioStreamCollector_041 +* @tc.desc : Test IsStreamActive. +*/ +HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_041, TestSize.Level1) +{ + AudioStreamCollector collector; + AudioStreamType volumeType = STREAM_VOICE_ASSISTANT; + shared_ptr rendererChangeInfo = make_shared(); + + rendererChangeInfo->createrUID = 1001; + rendererChangeInfo->clientUID = 1001; + rendererChangeInfo->sessionId = 2001; + rendererChangeInfo->rendererState = RENDERER_RUNNING; + collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo)); + + bool ret = collector.IsStreamActive(volumeType); + EXPECT_FALSE(ret); +} + /** * @tc.name : Test AudioStreamCollector. * @tc.number: AudioStreamCollector_042 diff --git a/services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..c1cfd1ef39752ba2923934b3c7ff931ee7e692ef --- /dev/null +++ b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_VOLUME_MANAGER_EXT_UNIT_TEST_H +#define AUDIO_VOLUME_MANAGER_EXT_UNIT_TEST_H +#include "gtest/gtest.h" +#include "audio_volume_manager.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioVolumeManagerExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_VOLUME_MANAGER_EXT_UNIT_TEST_H diff --git a/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..686d5e52f5ab4cd3d18f31da490fa1385407668b --- /dev/null +++ b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp @@ -0,0 +1,377 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sle_audio_device_manager.h" +#include "audio_volume_manager_ext_unit_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { +const int32_t RESTORE_VOLUME_NOTIFICATION_ID = 116000; +const int32_t INCREASE_VOLUME_NOTIFICATION_ID = 116001; +const uint32_t NOTIFICATION_BANNER_FLAG = 1 << 9; +const std::string AUDIO_RESTORE_VOLUME_EVENT = "AUDIO_RESTORE_VOLUME_EVENT"; +const std::string AUDIO_INCREASE_VOLUME_EVENT = "AUDIO_INCREASE_VOLUME_EVENT"; + +void AudioVolumeManagerExtUnitTest::SetUpTestCase(void) {} +void AudioVolumeManagerExtUnitTest::TearDownTestCase(void) {} + +void AudioVolumeManagerExtUnitTest::SetUp(void) +{ + std::shared_ptr audioPolicyServerHandler( + DelayedSingleton::GetInstance()); + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.Init(audioPolicyServerHandler); +} + +void AudioVolumeManagerExtUnitTest::TearDown(void) +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.DeInit(); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: GetSystemVolumeLevel_001 +* @tc.desc : Test GetSystemVolumeLevel interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, GetSystemVolumeLevel_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + int32_t zoneId = 0; + AudioStreamType streamType = STREAM_RING; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO; + audioVolumeManager->SetRingerModeMute(false); + int32_t ret = audioVolumeManager->GetSystemVolumeLevel(streamType, zoneId); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleA2dpAbsVolume_001 +* @tc.desc : Test HandleA2dpAbsVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleA2dpAbsVolume_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + int32_t volumeLevel = 0; + AudioStreamType streamType = STREAM_RING; + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + int32_t ret = audioVolumeManager->HandleA2dpAbsVolume(streamType, volumeLevel, deviceType); + EXPECT_NE(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleNearlinkDeviceAbsVolume_001 +* @tc.desc : Test HandleNearlinkDeviceAbsVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleNearlinkDeviceAbsVolume_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + DeviceType curOutputDeviceType = DEVICE_TYPE_SPEAKER; + AudioStreamType streamType = STREAM_MUSIC; + int32_t volumeLevel = 1000; + bool internalCall = true; + SleVolumeConfigInfo configInfo; + std::pair pairConfigInfo = std::make_pair(configInfo, configInfo); + SleAudioDeviceManager::GetInstance().deviceVolumeConfigInfo_["test"] = pairConfigInfo; + auto ret = audioVolumeManager->HandleNearlinkDeviceAbsVolume(streamType, volumeLevel, curOutputDeviceType); + EXPECT_NE(ret, ERROR); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleNearlinkDeviceAbsVolume_002 +* @tc.desc : Test HandleNearlinkDeviceAbsVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleNearlinkDeviceAbsVolume_002, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + DeviceType curOutputDeviceType = DEVICE_TYPE_SPEAKER; + std::string macAddress = "test"; + AudioStreamType streamType = STREAM_RING; + int32_t volumeLevel = 1000; + SleVolumeConfigInfo configInfo; + std::pair pairConfigInfo = std::make_pair(configInfo, configInfo); + SleAudioDeviceManager::GetInstance().deviceVolumeConfigInfo_["test"] = pairConfigInfo; + auto ret = audioVolumeManager->HandleNearlinkDeviceAbsVolume(streamType, volumeLevel, curOutputDeviceType); + EXPECT_NE(ret, ERROR); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: SetSystemVolumeLevel_001 +* @tc.desc : Test SetSystemVolumeLevel. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, SetSystemVolumeLevel_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + AudioStreamType streamType = STREAM_RING; + int32_t volumeLevel = 0; + EXPECT_EQ(VolumeUtils::GetVolumeTypeFromStreamType(streamType), STREAM_RING); + + auto ret = audioVolumeManager->SetSystemVolumeLevel(streamType, volumeLevel); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckBlueToothActiveMusicTime_001 + * @tc.desc : CheckBlueToothActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckBlueToothActiveMusicTime_001, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTimeBt_ = 68400; + volumeManager.CheckBlueToothActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckBlueToothActiveMusicTime_002 + * @tc.desc : CheckBlueToothActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckBlueToothActiveMusicTime_002, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTimeBt_ = 0; + volumeManager.activeSafeTime_ = 68400; + volumeManager.CheckBlueToothActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckBlueToothActiveMusicTime_003 + * @tc.desc : CheckBlueToothActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckBlueToothActiveMusicTime_003, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + int32_t currentTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + volumeManager.startSafeTimeBt_ = currentTime - 60; + volumeManager.CheckBlueToothActiveMusicTime(0); + EXPECT_GT(volumeManager.startSafeTimeBt_, currentTime - 60); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckWiredActiveMusicTime_001 + * @tc.desc : CheckWiredActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckWiredActiveMusicTime_001, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTime_ = 68400; + volumeManager.CheckWiredActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckWiredActiveMusicTime_002 + * @tc.desc : CheckWiredActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckWiredActiveMusicTime_002, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTimeBt_ = 68400; + volumeManager.activeSafeTime_ = 0; + volumeManager.CheckWiredActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckWiredActiveMusicTime_003 + * @tc.desc : CheckWiredActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckWiredActiveMusicTime_003, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + int32_t currentTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + volumeManager.startSafeTime_ = currentTime - 60; + volumeManager.CheckWiredActiveMusicTime(0); + EXPECT_GT(volumeManager.startSafeTime_, currentTime - 60); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleAbsBluetoothVolume_004 +* @tc.desc : Test HandleAbsBluetoothVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleAbsBluetoothVolume_004, TestSize.Level1) +{ + std::string macAddress = "11:22:33:44:55:66"; + int32_t volumeLevel = 0; + int32_t ret; + AudioStreamType streamType = STREAM_MUSIC; + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.isBtFirstBoot_ = false; + ret = audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel, true, streamType); + EXPECT_EQ(ret, 0); + + audioVolumeManager.isBtFirstBoot_ = false; + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + ret = audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel, false, streamType); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_001 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_CAR; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_002 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_002, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_SOUNDBOX; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_003 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_003, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatusBt_ = SAFE_INACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_004 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_004, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatus_ = SAFE_INACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, false); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_005 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_005, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatus_ = SAFE_ACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, false); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_006 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_006, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatusBt_ = SAFE_ACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: GetForceControlVolumeType_001 + * @tc.desc : Test GetForceControlVolumeType. + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, GetForceControlVolumeType_001, TestSize.Level4) +{ + auto &audioVolumeManager = AudioVolumeManager::GetInstance(); + ASSERT_EQ(audioVolumeManager.GetForceControlVolumeType(), STREAM_DEFAULT); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: IsNeedForceControlVolumeType_001 + * @tc.desc : Test IsNeedForceControlVolumeType. + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, IsNeedForceControlVolumeType_001, TestSize.Level4) +{ + auto &audioVolumeManager = AudioVolumeManager::GetInstance(); + ASSERT_EQ(audioVolumeManager.IsNeedForceControlVolumeType(), false); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: GetVolumeGroupInfosNotWait_001 + * @tc.desc : Test GetVolumeGroupInfosNotWait. + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, GetVolumeGroupInfosNotWait_001, TestSize.Level4) +{ + auto &audioVolumeManager = AudioVolumeManager::GetInstance(); + std::vector> infos; + ASSERT_EQ(audioVolumeManager.GetVolumeGroupInfosNotWait(infos), false); +} +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_zone_unit_test/src/audio_zone_client_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_zone_unit_test/src/audio_zone_client_manager_unit_test.cpp index ce6b16de8b949d10da2e69c4660918c5197c165a..7eed6afabc19f68161eb913dce217e4b7b36261d 100644 --- a/services/audio_policy/test/unittest/audio_zone_unit_test/src/audio_zone_client_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_zone_unit_test/src/audio_zone_client_manager_unit_test.cpp @@ -25,10 +25,106 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { +class IStandardAudioZoneClientUnitTest : public IStandardAudioZoneClient { +public: + sptr AsObject() override + { + return nullptr; + } + + ErrCode OnAudioZoneAdd(const AudioZoneDescriptor &zoneDescriptor) override + { + recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_ADD_EVENT; + Notify(); + return 0; + } + + ErrCode OnAudioZoneRemove(int32_t zoneId) override + { + recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_REMOVE_EVENT; + recvEvent_.zoneId = zoneId; + Notify(); + return 0; + } + + ErrCode OnAudioZoneChange(int32_t zoneId, const AudioZoneDescriptor& zoneDescriptor, + int32_t reason) override + { + recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_CHANGE_EVENT; + recvEvent_.zoneId = zoneId; + Notify(); + return 0; + } + + ErrCode OnInterruptEvent(int32_t zoneId, + const std::vector>& ipcInterrupts, + int32_t reason) override + { + recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT; + recvEvent_.zoneId = zoneId; + Notify(); + return 0; + } + + ErrCode OnInterruptEvent(int32_t zoneId, const std::string& deviceTag, + const std::vector>& ipcInterrupts, + int32_t reason) override + { + recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT; + recvEvent_.zoneId = zoneId; + recvEvent_.deviceTag = deviceTag; + Notify(); + return 0; + } + + ErrCode SetSystemVolume(int32_t zoneId, int32_t volumeType, int32_t volumeLevel, int32_t volumeFlag) override + { + volumeLevel_ = volumeLevel; + Notify(); + return 0; + } + + ErrCode GetSystemVolume(int32_t zoneId, int32_t volumeType, float& outVolume) override + { + Notify(); + return volumeLevel_; + } + + void Notify() + { + std::unique_lock lock(waitLock_); + waitStatus_ = 1; + waiter_.notify_one(); + } + + void Wait() + { + std::unique_lock lock(waitLock_); + if (waitStatus_ == 0) { + waiter_.wait(lock, [this] { + return waitStatus_ != 0; + }); + } + waitStatus_ = 0; + } + + struct AudioZoneEvent recvEvent_; + std::condition_variable waiter_; + std::mutex waitLock_; + int32_t waitStatus_ = 0; + int32_t volumeLevel_ = 0; +}; + void AudioZoneClientManagerUnitTest::SetUpTestCase(void) {} void AudioZoneClientManagerUnitTest::TearDownTestCase(void) {} -void AudioZoneClientManagerUnitTest::SetUp(void) {} -void AudioZoneClientManagerUnitTest::TearDown(void) {} +void AudioZoneClientManagerUnitTest::SetUp(void) +{ + AudioZoneClientManager::GetInstance().clients_.clear(); +} +void AudioZoneClientManagerUnitTest::TearDown(void) +{ + AudioZoneClientManager::GetInstance().clients_.clear(); +} /** * @tc.name : Test AudioZoneClientManagerUnitTest. @@ -66,6 +162,273 @@ HWTEST_F(AudioZoneClientManagerUnitTest, UnRegisterAudioZoneClient_001, TestSize EXPECT_TRUE(AudioZoneClientManager::GetInstance().clients_.find(clientPid) == AudioZoneClientManager::GetInstance().clients_.end()); } + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_002 + * @tc.desc : Test RegisterAudioZoneClient interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_002, TestSize.Level4) +{ + AudioZoneClientManager manager(nullptr); + + pid_t pid = 101; + int32_t ret = manager.RegisterAudioZoneClient(pid, nullptr); + + EXPECT_EQ(ret, ERROR); + EXPECT_FALSE(manager.IsRegisterAudioZoneClient(pid)); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_003 + * @tc.desc : Test RegisterAudioZoneClient interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_003, TestSize.Level4) +{ + pid_t pid = 102; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + + int32_t ret = AudioZoneClientManager::GetInstance().RegisterAudioZoneClient(pid, client); + EXPECT_EQ(ret, SUCCESS); + + auto& mapRef = AudioZoneClientManager::GetInstance().clients_; + auto it = mapRef.find(pid); + EXPECT_TRUE(it != mapRef.end()); + EXPECT_EQ(it->second, client); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_004 + * @tc.desc : Test RegisterAudioZoneClient interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_004, TestSize.Level4) +{ + pid_t pid = 103; + sptr client1 = new IStandardAudioZoneClientUnitTest(); + sptr client2 = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client1, nullptr); + ASSERT_NE(client2, nullptr); + + EXPECT_EQ(AudioZoneClientManager::GetInstance().RegisterAudioZoneClient(pid, client1), SUCCESS); + EXPECT_EQ(AudioZoneClientManager::GetInstance().RegisterAudioZoneClient(pid, client2), SUCCESS); + + auto& mapRef = AudioZoneClientManager::GetInstance().clients_; + EXPECT_EQ(mapRef[pid], client2); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_005 + * @tc.desc : Test UnRegisterAudioZoneClient interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_005, TestSize.Level4) +{ + pid_t pid = 101; + auto& mapRef = AudioZoneClientManager::GetInstance().clients_; + EXPECT_TRUE(mapRef.find(pid) == mapRef.end()); + + AudioZoneClientManager::GetInstance().UnRegisterAudioZoneClient(pid); + EXPECT_TRUE(mapRef.empty()); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_006 + * @tc.desc : Test UnRegisterAudioZoneClient interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_006, TestSize.Level4) +{ + pid_t pid = 102; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + + auto& mapRef = AudioZoneClientManager::GetInstance().clients_; + mapRef[pid] = client; + EXPECT_TRUE(mapRef.find(pid) != mapRef.end()); + + AudioZoneClientManager::GetInstance().UnRegisterAudioZoneClient(pid); + EXPECT_TRUE(mapRef.find(pid) == mapRef.end()); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_007 + * @tc.desc : Test DispatchEvent interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_007, TestSize.Level4) +{ + auto& manager = AudioZoneClientManager::GetInstance(); + + pid_t pid = 101; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + manager.clients_[pid] = client; + + auto event = std::make_shared(); + event->type = AudioZoneEventType::AUDIO_ZONE_ADD_EVENT; + event->clientPid = pid; + event->descriptor = std::make_shared(); + ASSERT_NE(event->descriptor, nullptr); + event->descriptor->zoneId_ = 201; + + manager.DispatchEvent(event); + + auto testClient = static_cast(client.GetRefPtr()); + testClient->Wait(); + EXPECT_EQ(testClient->recvEvent_.type, AudioZoneEventType::AUDIO_ZONE_ADD_EVENT); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_008 + * @tc.desc : Test DispatchEvent interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_008, TestSize.Level4) +{ + auto& manager = AudioZoneClientManager::GetInstance(); + + pid_t pid = 102; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + manager.clients_[pid] = client; + + auto event = std::make_shared(); + event->type = AudioZoneEventType::AUDIO_ZONE_REMOVE_EVENT; + event->clientPid = pid; + event->zoneId = 202; + + manager.DispatchEvent(event); + + auto testClient = static_cast(client.GetRefPtr()); + testClient->Wait(); + EXPECT_EQ(testClient->recvEvent_.type, AudioZoneEventType::AUDIO_ZONE_REMOVE_EVENT); + EXPECT_EQ(testClient->recvEvent_.zoneId, 202); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_009 + * @tc.desc : Test DispatchEvent interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_009, TestSize.Level4) +{ + auto& manager = AudioZoneClientManager::GetInstance(); + + pid_t pid = 103; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + manager.clients_[pid] = client; + + auto event = std::make_shared(); + event->type = AudioZoneEventType::AUDIO_ZONE_CHANGE_EVENT; + event->clientPid = pid; + event->zoneId = 203; + event->descriptor = std::make_shared(); + ASSERT_NE(event->descriptor, nullptr); + event->descriptor->zoneId_ = 203; + event->zoneChangeReason = static_cast(3); + + manager.DispatchEvent(event); + + auto testClient = static_cast(client.GetRefPtr()); + testClient->Wait(); + EXPECT_EQ(testClient->recvEvent_.type, AudioZoneEventType::AUDIO_ZONE_CHANGE_EVENT); + EXPECT_EQ(testClient->recvEvent_.zoneId, 203); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_010 + * @tc.desc : Test DispatchEvent interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_010, TestSize.Level4) +{ + auto& manager = AudioZoneClientManager::GetInstance(); + + pid_t pid = 104; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + manager.clients_[pid] = client; + + auto event = std::make_shared(); + event->type = AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT; + event->clientPid = pid; + event->zoneId = 204; + event->deviceTag = ""; + event->zoneInterruptReason = static_cast(2); + event->interrupts.clear(); + + manager.DispatchEvent(event); + + auto testClient = static_cast(client.GetRefPtr()); + testClient->Wait(); + EXPECT_EQ(testClient->recvEvent_.type, AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT); + EXPECT_EQ(testClient->recvEvent_.zoneId, 204); + EXPECT_TRUE(testClient->recvEvent_.deviceTag.empty()); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_011 + * @tc.desc : Test DispatchEvent interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_011, TestSize.Level4) +{ + auto& manager = AudioZoneClientManager::GetInstance(); + + pid_t pid = 105; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + manager.clients_[pid] = client; + + auto event = std::make_shared(); + event->type = AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT; + event->clientPid = pid; + event->zoneId = 205; + event->deviceTag = "BT_SPK"; + event->zoneInterruptReason = static_cast(5); + event->interrupts.clear(); + + manager.DispatchEvent(event); + + auto testClient = static_cast(client.GetRefPtr()); + testClient->Wait(); + EXPECT_EQ(testClient->recvEvent_.type, AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT); + EXPECT_EQ(testClient->recvEvent_.zoneId, 205); + EXPECT_EQ(testClient->recvEvent_.deviceTag, "BT_SPK"); +} + +/** + * @tc.name : Test AudioZoneClientManagerUnitTest. + * @tc.number: AudioZoneClientManager_012 + * @tc.desc : Test DispatchEvent interface. + */ +HWTEST_F(AudioZoneClientManagerUnitTest, AudioZoneClientManager_012, TestSize.Level4) +{ + auto& manager = AudioZoneClientManager::GetInstance(); + + pid_t pid = 106; + sptr client = new IStandardAudioZoneClientUnitTest(); + ASSERT_NE(client, nullptr); + manager.clients_[pid] = client; + + auto event = std::make_shared(); + event->type = static_cast(999); + event->clientPid = pid; + event->zoneId = 206; + + auto testClient = static_cast(client.GetRefPtr()); + testClient->recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_REMOVE_EVENT; + testClient->waitStatus_ = 0; + + manager.DispatchEvent(event); + + EXPECT_EQ(testClient->recvEvent_.type, AudioZoneEventType::AUDIO_ZONE_REMOVE_EVENT); + EXPECT_EQ(testClient->waitStatus_, 0); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp b/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp index 36e11f5d251f8c6dde94708fd29f456128729a71..584e708a9a01e59bcb2db21f34219855d9fd2cf4 100644 --- a/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp +++ b/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp @@ -25,6 +25,9 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { +const static int32_t TEST_CLIENT_UID = 1; +const static uint32_t TEST_SESSION_ID = 1; + void PrivacyPriorityRouterUnitTest::SetUpTestCase(void) {} void PrivacyPriorityRouterUnitTest::TearDownTestCase(void) {} void PrivacyPriorityRouterUnitTest::SetUp(void) {} @@ -39,8 +42,8 @@ HWTEST(PrivacyPriorityRouterUnitTest, GetRecordCaptureDevice_002, TestSize.Level { PrivacyPriorityRouter privacyPriorityRouter; SourceType sourceType = SOURCE_TYPE_VOICE_RECOGNITION; - int32_t clientUID = 1; - uint32_t sessionID = 1; + int32_t clientUID = TEST_CLIENT_UID; + uint32_t sessionID = TEST_SESSION_ID; auto result = privacyPriorityRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); EXPECT_NE(result, nullptr); } @@ -54,8 +57,8 @@ HWTEST(PrivacyPriorityRouterUnitTest, GetRecordCaptureDevice_003, TestSize.Level { PrivacyPriorityRouter privacyPriorityRouter; SourceType sourceType = SOURCE_TYPE_INVALID; - int32_t clientUID = 1; - uint32_t sessionID = 1; + int32_t clientUID = TEST_CLIENT_UID; + uint32_t sessionID = TEST_SESSION_ID; auto result = privacyPriorityRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); EXPECT_NE(result, nullptr); } @@ -69,8 +72,8 @@ HWTEST(PrivacyPriorityRouterUnitTest, GetRecordCaptureDevice_004, TestSize.Level { PrivacyPriorityRouter privacyPriorityRouter; SourceType sourceType = SOURCE_TYPE_INVALID; - int32_t clientUID = 1; - uint32_t sessionID = 1; + int32_t clientUID = TEST_CLIENT_UID; + uint32_t sessionID = TEST_SESSION_ID; shared_ptr desc = make_shared(); desc->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO; auto result = privacyPriorityRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); @@ -86,7 +89,7 @@ HWTEST(PrivacyPriorityRouterUnitTest, GetCallRenderDevice_001, TestSize.Level1) { PrivacyPriorityRouter privacyPriorityRouter; StreamUsage streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION; - int32_t clientUID = 12345; + int32_t clientUID = TEST_CLIENT_UID; auto result = privacyPriorityRouter.GetCallRenderDevice(streamUsage, clientUID); EXPECT_NE(result, nullptr); } @@ -100,7 +103,7 @@ HWTEST(PrivacyPriorityRouterUnitTest, GetCallRenderDevice_002, TestSize.Level1) { PrivacyPriorityRouter privacyPriorityRouter; StreamUsage streamUsage = STREAM_USAGE_MEDIA; - int32_t clientUID = 12345; + int32_t clientUID = TEST_CLIENT_UID; auto result = privacyPriorityRouter.GetCallRenderDevice(streamUsage, clientUID); EXPECT_NE(result, nullptr); } @@ -136,6 +139,65 @@ HWTEST(PrivacyPriorityRouterUnitTest, PrivacyPriorityRouter_002, TestSize.Level1 EXPECT_EQ(1, router.GetRingRenderDevices(STREAM_USAGE_RINGTONE, 1).size()); EXPECT_EQ(1, router.GetRingRenderDevices(STREAM_USAGE_ALARM, 1).size()); } + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: GetMediaRenderDevice_001 + * @tc.desc : Test GetMediaRenderDevice interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, GetMediaRenderDevice_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + StreamUsage streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION; + int32_t clientUID = TEST_CLIENT_UID; + auto ret = router.GetMediaRenderDevice(streamUsage, clientUID); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: GetCallCaptureDevice_001 + * @tc.desc : Test GetCallCaptureDevice interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, GetCallCaptureDevice_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + SourceType sourceType = SOURCE_TYPE_VOICE_RECOGNITION; + int32_t clientUID = TEST_CLIENT_UID; + uint32_t sessionID = TEST_SESSION_ID; + auto ret = router.GetCallCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: GetToneRenderDevice_001 + * @tc.desc : Test GetToneRenderDevice interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, GetToneRenderDevice_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + StreamUsage streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION; + int32_t clientUID = TEST_CLIENT_UID; + auto ret = router.GetToneRenderDevice(streamUsage, clientUID); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: RemoveArmUsb_001 + * @tc.desc : Test RemoveArmUsb interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, RemoveArmUsb_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + vector> descs; + shared_ptr desc = std::make_shared(); + desc->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + descs.emplace_back(desc); + router.RemoveArmUsb(descs); + EXPECT_EQ(descs.size(), 0); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h b/services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..097c2abd998ca814006e41eb93698471a0cbb2c7 --- /dev/null +++ b/services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USER_SELECT_ROUTER_EXT_UNIT_TEST_H +#define USER_SELECT_ROUTER_EXT_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_system_manager.h" +#include "user_select_router.h" + +namespace OHOS { +namespace AudioStandard { + +class UserSelectRouterExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // USER_SELECT_ROUTER_EXT_UNIT_TEST_H diff --git a/services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp b/services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e67141f13b02a8a5c71e2fa948c299a5aadb5a35 --- /dev/null +++ b/services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp @@ -0,0 +1,227 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "user_select_router_ext_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" +#include "audio_policy_server.h" +#include "audio_policy_service.h" + +#include +#include +#include +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void UserSelectRouterExtUnitTest::SetUpTestCase(void) {} +void UserSelectRouterExtUnitTest::TearDownTestCase(void) {} +void UserSelectRouterExtUnitTest::SetUp(void) {} +void UserSelectRouterExtUnitTest::TearDown(void) {} + +/** + * @tc.name : Test GetMediaRenderDevice. + * @tc.number: GetMediaRenderDevice_004 + * @tc.desc : GetMediaRenderDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetMediaRenderDevice_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + int32_t clientUID = 1; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = MEDIA; + auto result = userSelectRouter.GetMediaRenderDevice(STREAM_USAGE_MEDIA, clientUID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetMediaRenderDevice. + * @tc.number: GetCallRenderDevice_004 + * @tc.desc : GetCallRenderDevice + */ +HWTEST(UserSelectRouterExtUnitTest, GetCallRenderDevice_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + int32_t clientUID = 1; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = VOICE; + auto result = userSelectRouter.GetCallRenderDevice(STREAM_USAGE_VOICE_MESSAGE, clientUID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetCallCaptureDevice. + * @tc.number: GetCallCaptureDevice_003 + * @tc.desc : GetCallCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetCallCaptureDevice_003, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 1; + preferredDevice->deviceUsage_ = VOICE; + AudioStateManager::GetAudioStateManager().SetPreferredCallRenderDevice(preferredDevice); + auto result = userSelectRouter.GetCallCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetCallCaptureDevice. + * @tc.number: GetCallCaptureDevice_004 + * @tc.desc : GetCallCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetCallCaptureDevice_004, TestSize.Level4) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + AudioStateManager::GetAudioStateManager().SetPreferredCallRenderDevice(preferredDevice); + + auto result = userSelectRouter.GetCallCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_004 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_WIRED_HEADSET; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_RINGTONE, clientUID); + EXPECT_EQ(descs.size(), 1); +} + +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_005 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_005, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_VOICE_RINGTONE, clientUID); + EXPECT_EQ(descs.size(), 1); +} + +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_006 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_006, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_NONE; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_ALARM, clientUID); + EXPECT_EQ(descs.size(), 1); +} +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_007 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_007, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_WIRED_HEADSET; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_ALARM, clientUID); + EXPECT_EQ(descs.size(), 1); +} + +/** + * @tc.name : Test GetRecordCaptureDevice. + * @tc.number: GetRecordCaptureDevice_003 + * @tc.desc : GetRecordCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRecordCaptureDevice_003, TestSize.Level4) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = MEDIA; + auto result = userSelectRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetRecordCaptureDevice. + * @tc.number: GetRecordCaptureDevice_004 + * @tc.desc : GetRecordCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRecordCaptureDevice_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_TRANSCRIPTION; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = MEDIA; + auto result = userSelectRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp b/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp index 2624f623db5a49c141331571b673e8a76b15f3a5..7582a6b9d12d4cac7d39464e1b99c9d3d45a7911 100644 --- a/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp +++ b/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp @@ -999,5 +999,312 @@ HWTEST(VolumeDataMaintainerUnitTest, SetAppStreamMuted_001, TestSize.Level1) EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), false); EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, anotherStreamType), false); } + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetDataShareReady_001. + * @tc.desc : Test SetDataShareReady API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetDataShareReady_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + std::atomic isDataShareReady = false; + volumeDataMaintainerRet->SetDataShareReady(std::atomic_load(&isDataShareReady)); + AudioSettingProvider& audioSettingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID); + EXPECT_FALSE(audioSettingProvider.isDataShareReady_); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetStreamVolume_001. + * @tc.desc : Test SetStreamVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetStreamVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetStreamVolume(streamType, volumeLevel); + EXPECT_FALSE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetAppVolume_001. + * @tc.desc : Test SetAppVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetAppVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); + EXPECT_TRUE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetAppVolumeMuted_001. + * @tc.desc : Test SetAppVolumeMuted API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetAppVolumeMuted_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + bool muted = true; + volumeDataMaintainerRet->SetAppVolumeMuted(appUid, muted); + EXPECT_TRUE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamVolume_001. + * @tc.desc : Test GetStreamVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t ret = volumeDataMaintainerRet->GetStreamVolume(streamType); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetDeviceVolume_001. + * @tc.desc : Test GetDeviceVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t ret = volumeDataMaintainerRet->GetDeviceVolume(deviceType, streamType); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetAppVolume_001. + * @tc.desc : Test GetAppVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetAppVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); + int32_t ret = volumeDataMaintainerRet->GetAppVolume(appUid); + EXPECT_NE(ret, 0); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: IsSetAppVolume_001. + * @tc.desc : Test IsSetAppVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, IsSetAppVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); + bool ret = volumeDataMaintainerRet->IsSetAppVolume(appUid); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetVolumeMap_001. + * @tc.desc : Test GetVolumeMap API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetVolumeMap_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 10; + volumeDataMaintainerRet->volumeLevelMap_[streamType] = volumeLevel; + auto ret = volumeDataMaintainerRet->GetVolumeMap(); + EXPECT_FALSE(ret.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetMuteStatus_001. + * @tc.desc : Test GetMuteStatus API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetMuteStatus_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string networkId = "111"; + bool ret = volumeDataMaintainerRet->GetMuteStatus(deviceType, streamType, networkId); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetStreamMuteStatus_001. + * @tc.desc : Test SetStreamMuteStatus API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetStreamMuteStatus_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool muteStatus = false; + bool ret = volumeDataMaintainerRet->SetStreamMuteStatus(streamType, muteStatus); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamMute_001. + * @tc.desc : Test GetStreamMute API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamMute_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool muteStatus = false; + volumeDataMaintainerRet->SetStreamMuteStatus(streamType, muteStatus); + bool ret = volumeDataMaintainerRet->GetStreamMute(streamType); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: CheckOsAccountReady_001. + * @tc.desc : Test CheckOsAccountReady API. + */ +HWTEST(VolumeDataMaintainerUnitTest, CheckOsAccountReady_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + bool ret = volumeDataMaintainerRet->CheckOsAccountReady(); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetVolumeKeyForDatabaseVolumeName_001. + * @tc.desc : Test GetVolumeKeyForDatabaseVolumeName API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetVolumeKeyForDatabaseVolumeName_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + std::string databaseVolumeName = "VolumeDataMaintainerUnitTest"; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string expect = "VolumeDataMaintainerUnitTest_music_volume"; + std::string ret = volumeDataMaintainerRet->GetVolumeKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); + + streamType = AudioStreamType::STREAM_DEFAULT; + expect = ""; + ret = volumeDataMaintainerRet->GetVolumeKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetMuteKeyForDatabaseVolumeName_001. + * @tc.desc : Test GetMuteKeyForDatabaseVolumeName API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetMuteKeyForDatabaseVolumeName_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + std::string databaseVolumeName = "VolumeDataMaintainerUnitTest"; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string expect = "VolumeDataMaintainerUnitTest_music_mute_status"; + std::string ret = volumeDataMaintainerRet->GetMuteKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); + + streamType = AudioStreamType::STREAM_DEFAULT; + expect = ""; + ret = volumeDataMaintainerRet->GetMuteKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SaveVolumeInternal_001. + * @tc.desc : Test SaveVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SaveVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType type = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 10; + std::string networkId = "111"; + bool ret = volumeDataMaintainerRet->SaveVolumeInternal(type, streamType, volumeLevel, networkId); + EXPECT_FALSE(ret); + + streamType = AudioStreamType::STREAM_DEFAULT; + ret = volumeDataMaintainerRet->SaveVolumeInternal(type, streamType, volumeLevel, networkId); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetVolumeInternal_001. + * @tc.desc : Test GetVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType type = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string networkId = "111"; + bool ret = volumeDataMaintainerRet->GetVolumeInternal(type, streamType, networkId); + EXPECT_FALSE(ret); + + streamType = AudioStreamType::STREAM_DEFAULT; + ret = volumeDataMaintainerRet->GetVolumeInternal(type, streamType, networkId); + EXPECT_FALSE(ret); + + streamType = AudioStreamType::STREAM_VOICE_CALL_ASSISTANT; + ret = volumeDataMaintainerRet->GetVolumeInternal(type, streamType, networkId); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetStreamVolumeInternal_001. + * @tc.desc : Test SetStreamVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetStreamVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 10; + volumeDataMaintainerRet->SetStreamVolumeInternal(streamType, volumeLevel); + EXPECT_FALSE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamMuteInternal_001. + * @tc.desc : Test GetStreamMuteInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamMuteInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool ret = volumeDataMaintainerRet->GetStreamMuteInternal(streamType); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamVolumeInternal_001. + * @tc.desc : Test GetStreamVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t ret = volumeDataMaintainerRet->GetStreamVolumeInternal(streamType); + EXPECT_EQ(ret, 0); +} } // AudioStandardnamespace } // OHOSnamespace diff --git a/services/audio_service/client/include/audio_manager_base.h b/services/audio_service/client/include/audio_manager_base.h index e1732fc2e164a850198298d9ef46d0bd12fb9fc4..05bbcfb26b94eb1b929ca60fca06a65c3e05f8e2 100644 --- a/services/audio_service/client/include/audio_manager_base.h +++ b/services/audio_service/client/include/audio_manager_base.h @@ -16,7 +16,6 @@ #ifndef I_ST_AUDIO_MANAGER_BASE_H #define I_ST_AUDIO_MANAGER_BASE_H -#include "iremote_object.h" #include "audio_stutter.h" #include "audio_workgroup_ipc.h" diff --git a/services/audio_service/client/include/core_service_provider_stub.h b/services/audio_service/client/include/core_service_provider_stub.h index 6cef2455263112f59946457490b759d5cbf79783..b086603f4a17d48b9e3e428006d2158ef5701233 100644 --- a/services/audio_service/client/include/core_service_provider_stub.h +++ b/services/audio_service/client/include/core_service_provider_stub.h @@ -36,6 +36,8 @@ public: int32_t GenerateSessionId(uint32_t &sessionId) override; int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config, int32_t &ret) override; + int32_t GetVoiceMuteState(uint32_t sessionId, bool &muteState) override; + int32_t RemoveVoiceMuteState(uint32_t sessionId) override; private: ICoreServiceProvider *coreServiceWorker_; }; diff --git a/services/audio_service/client/include/renderer_in_client_private.h b/services/audio_service/client/include/renderer_in_client_private.h index e0c30bdfaa8a60abdd2e723563d8dcac2de6dbdf..e847917ac8e8f2ed8ac1a2eaa7bb8939e379fb76 100644 --- a/services/audio_service/client/include/renderer_in_client_private.h +++ b/services/audio_service/client/include/renderer_in_client_private.h @@ -295,6 +295,7 @@ private: bool CheckBufferValid(const BufferDesc &bufDesc); bool IsRestoreNeeded(); + void RecordDropPosition(size_t dataLength); private: AudioStreamType eStreamType_ = AudioStreamType::STREAM_DEFAULT; int32_t appUid_ = 0; @@ -441,6 +442,8 @@ private: }; std::vector lastSwitchPosition_ = {0, 0}; std::vector lastSwitchPositionWithSpeed_ = {0, 0}; + std::atomic dropPosition_ = 0; + std::atomic dropHdiPosition_ = 0; struct WrittenFramesWithSpeed { uint64_t writtenFrames = 0; diff --git a/services/audio_service/client/src/audio_system_manager.cpp b/services/audio_service/client/src/audio_system_manager.cpp index 88e8697cc10a2cf66d3e7111af17d9289ef3285c..992a247cee8f0cb8bc1b1bfeceddc995dac1777b 100644 --- a/services/audio_service/client/src/audio_system_manager.cpp +++ b/services/audio_service/client/src/audio_system_manager.cpp @@ -2598,5 +2598,16 @@ std::shared_ptr AudioSystemManager::G } return nullptr; } + +int32_t AudioSystemManager::GetVolumeBySessionId(const uint32_t &sessionId, float &volume) +{ + const sptr gasp = GetAudioSystemManagerProxy(); + CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERR_INVALID_PARAM, "Audio service unavailable."); + std::string identity = IPCSkeleton::ResetCallingIdentity(); + int32_t ret = gasp->GetVolumeBySessionId(sessionId, volume); + IPCSkeleton::SetCallingIdentity(identity); + CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed: %{public}d", ret); + return ret; +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/core_service_provider_stub.cpp b/services/audio_service/client/src/core_service_provider_stub.cpp index 93bdbef41f982795900a96d51be3a68157c59b06..38bcb4dee1793a69a16d06a58179017f6d1c6762 100644 --- a/services/audio_service/client/src/core_service_provider_stub.cpp +++ b/services/audio_service/client/src/core_service_provider_stub.cpp @@ -19,6 +19,7 @@ #include "core_service_provider_stub.h" #include "audio_service_log.h" #include "audio_errors.h" +#include "audio_utils.h" namespace OHOS { namespace AudioStandard { @@ -82,5 +83,20 @@ int32_t CoreServiceProviderWrapper::SetWakeUpAudioCapturerFromAudioServer( ret = coreServiceWorker_->SetWakeUpAudioCapturerFromAudioServer(config); return SUCCESS; } + +int32_t CoreServiceProviderWrapper::GetVoiceMuteState(uint32_t sessionId, bool &muteState) +{ + CHECK_AND_RETURN_RET_LOG(coreServiceWorker_ != nullptr, AUDIO_INIT_FAIL, "coreServiceWorker_ is null"); + coreServiceWorker_->GetVoiceMuteState(sessionId, muteState); + return SUCCESS; +} + +int32_t CoreServiceProviderWrapper::RemoveVoiceMuteState(uint32_t sessionId) +{ + CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifyIsAudio(), AUDIO_PERMISSION_DENIED, "only audio is allowed"); + CHECK_AND_RETURN_RET_LOG(coreServiceWorker_ != nullptr, AUDIO_INIT_FAIL, "coreServiceWorker_ is null"); + coreServiceWorker_->RemoveVoiceMuteState(sessionId); + return SUCCESS; +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/renderer_in_client.cpp b/services/audio_service/client/src/renderer_in_client.cpp index 4d940c17de0e6facea2604f9701e8a1eb81716f8..5b85791635f69f6f465522f12aeecb8feb7e60cd 100644 --- a/services/audio_service/client/src/renderer_in_client.cpp +++ b/services/audio_service/client/src/renderer_in_client.cpp @@ -343,6 +343,19 @@ bool RendererInClientInner::WaitForRunning() return true; } +void RendererInClientInner::RecordDropPosition(size_t bufLength) +{ + CHECK_AND_RETURN_LOG(isHdiSpeed_.load(), "record drop position only when is hdi speed "); + uint32_t channels = clientConfig_.streamInfo.channels; + uint32_t samplePerFrame = Util::GetSamplePerFrame(clientConfig_.streamInfo.format); + // calculate samples by dropped buffer size + uint32_t dropPostion = bufLength / (channels * samplePerFrame); + dropPosition_ += dropPostion; + dropHdiPosition_ += dropPostion / GetSpeed(); + AUDIO_WARNING_LOG("RendererInClientInner::RecordDropPosition dropPosition_:%{public}" PRIu64 + ",dropHdiPosition_:%{public}" PRIu64, dropPosition_.load(), dropHdiPosition_.load()); +} + int32_t RendererInClientInner::ProcessWriteInner(BufferDesc &bufferDesc) { int32_t result = 0; // Ensure result with default value. @@ -370,6 +383,7 @@ int32_t RendererInClientInner::ProcessWriteInner(BufferDesc &bufferDesc) } if (result < 0) { AUDIO_WARNING_LOG("Call write fail, result:%{public}d, bufLength:%{public}zu", result, bufferDesc.bufLength); + RecordDropPosition(bufferDesc.bufLength); } return result; } @@ -703,6 +717,8 @@ void RendererInClientInner::ResetFramePosition() lastFramePosAndTimePairWithSpeed_[base].first = 0; lastSwitchPosition_[base] = 0; } + dropPosition_ = 0; + dropHdiPosition_ = 0; unprocessedFramesBytes_ = 0; totalBytesWrittenAfterFlush_ = 0; writtenAtSpeedChange_.store(WrittenFramesWithSpeed{0, speed_}); diff --git a/services/audio_service/client/src/renderer_in_client_public.cpp b/services/audio_service/client/src/renderer_in_client_public.cpp index 31d93feac501baa5d834a554afaed26549e55565..5598c0274cde28e8d12966d89801b389021bd5d7 100644 --- a/services/audio_service/client/src/renderer_in_client_public.cpp +++ b/services/audio_service/client/src/renderer_in_client_public.cpp @@ -388,7 +388,7 @@ void RendererInClientInner::SetSwitchInfoTimestamp( uint64_t durationWithSpeedNS = timestampNS > lastTimeWithSpeedNS && lastTimeWithSpeedNS > 0 ? timestampNS - lastTimeWithSpeedNS : 0; uint64_t durationWithSpeedUS = durationWithSpeedNS / AUDIO_US_PER_MS; - float speed = realSpeed_.has_value() ? realSpeed_.value() : 1; + float speed = GetSpeed(); uint64_t newPositionWithSpeedUS = lastFramePosAndTimePairWithSpeed[base].first + durationWithSpeedUS * curStreamParams_.samplingRate * speed / AUDIO_US_PER_S; lastSwitchPositionWithSpeed_[base] = newPositionWithSpeedUS; @@ -410,6 +410,7 @@ bool RendererInClientInner::GetAudioPosition(Timestamp ×tamp, Timestamp::Ti uint64_t framePosition = readIdx > lastSpeedFlushReadIndex_ ? readIdx - lastSpeedFlushReadIndex_ : 0; framePosition = framePosition > latency ? framePosition - latency : 0; + framePosition += dropHdiPosition_.load(); framePosition += lastSwitchPosition_[base]; // reset the timestamp @@ -1526,6 +1527,7 @@ void RendererInClientInner::GetStreamSwitchInfo(IAudioStream::SwitchInfo& info) info.renderPeriodPositionCb = rendererPeriodPositionCallback_; info.rendererWriteCallback = writeCb_; + info.unprocessSamples = unprocessedFramesBytes_.load(); } IAudioStream::StreamClass RendererInClientInner::GetStreamClass() @@ -1869,6 +1871,7 @@ int32_t RendererInClientInner::GetAudioTimestampInfo(Timestamp ×tamp, Times frameLatency += SONIC_LATENCY_IN_MS * curStreamParams_.samplingRate / AUDIO_MS_PER_SECOND; // real frameposition uint64_t framePosition = unprocessSamples > frameLatency ? unprocessSamples - frameLatency : 0; + framePosition += dropPosition_.load(); framePosition += lastSwitchPositionWithSpeed_[base]; // reset the timestamp diff --git a/services/audio_service/common/include/audio_stream_checker.h b/services/audio_service/common/include/audio_stream_checker.h index 160fd4197d9c2a3e182f6ecb91ef0e18df8cb4aa..2db284f7d4e31ba51ffb2cc5fd17c4722627322e 100644 --- a/services/audio_service/common/include/audio_stream_checker.h +++ b/services/audio_service/common/include/audio_stream_checker.h @@ -63,6 +63,7 @@ public: void RecordStandbyTime(bool isStart); void UpdateAppState(bool isBackground); void SetVolume(float volume); + float GetVolume(); private: bool IsMonitorMuteFrame(const CheckerParam ¶); bool IsMonitorNoDataFrame(const CheckerParam ¶); diff --git a/services/audio_service/common/include/audio_stream_monitor.h b/services/audio_service/common/include/audio_stream_monitor.h index 2ca07a10fc68884a6ec2ada4913c575dc20757a1..38fa7424223dbe4692bc5513ee1ea041ef6edb93 100644 --- a/services/audio_service/common/include/audio_stream_monitor.h +++ b/services/audio_service/common/include/audio_stream_monitor.h @@ -49,6 +49,7 @@ public: void OnCallbackAppDied(const int32_t pid); void NotifyAppStateChange(const int32_t uid, bool isBackground); void UpdateMonitorVolume(const uint32_t &sessionId, const float &volume); + int32_t GetVolumeBySessionId(const uint32_t &sessionId, float &volume); private: AudioStreamMonitor() {} ~AudioStreamMonitor() {} @@ -56,6 +57,7 @@ private: std::map, DataTransferMonitorParam> registerInfo_; std::map> audioStreamCheckers_; std::mutex regStatusMutex_; + std::mutex callbackMutex_; DataTransferStateChangeCallbackForMonitor *audioServer_ = nullptr; }; } diff --git a/services/audio_service/common/include/audio_volume.h b/services/audio_service/common/include/audio_volume.h index d8bdf08d4cf314cad097aef5f93a93b58503f46b..526c30a0f9e30dc8ba58152ccd35fe11849589d4 100644 --- a/services/audio_service/common/include/audio_volume.h +++ b/services/audio_service/common/include/audio_volume.h @@ -92,6 +92,8 @@ public: void SetDoNotDisturbStatus(bool isDoNotDisturb); void SetOffloadType(uint32_t streamIndex, int32_t offloadType); int32_t GetOffloadType(uint32_t streamIndex); + void SetOffloadEnable(uint32_t streamIndex, int32_t offloadEnable); + int32_t GetOffloadEnable(uint32_t streamIndex); private: AudioVolume(); float GetAppVolumeInternal(int32_t appUid, AudioVolumeMode mode); @@ -106,6 +108,7 @@ private: std::unordered_map fadeoutState_{}; std::unordered_map stopFadeoutState_{}; std::unordered_map offloadType_{}; + std::unordered_map offloadEnable_{}; int32_t defaultAppVolume_ = 0; std::shared_ptr> setStreamVolumeInfo_ = diff --git a/services/audio_service/common/include/audio_volume_c.h b/services/audio_service/common/include/audio_volume_c.h index 050421dcbbdc482ce8c23ea8964e6a58033fe4bc..edff99f23ed6c83d097cd28b36bd30279c39b191 100644 --- a/services/audio_service/common/include/audio_volume_c.h +++ b/services/audio_service/common/include/audio_volume_c.h @@ -75,6 +75,9 @@ void SetOffloadType(uint32_t streamIndex, int32_t offloadType); int32_t GetOffloadType(uint32_t streamIndex); +void SetOffloadEnable(uint32_t streamIndex, int32_t offloadEnable); + +int32_t GetOffloadEnable(uint32_t streamIndex); #ifdef __cplusplus } #endif diff --git a/services/audio_service/common/include/i_core_service_provider.h b/services/audio_service/common/include/i_core_service_provider.h index 17b7fc74173c3494a1cce489059ed763bd4139b2..cb6f772f1104a2ca441d630f099e73f7748b1b4a 100644 --- a/services/audio_service/common/include/i_core_service_provider.h +++ b/services/audio_service/common/include/i_core_service_provider.h @@ -36,6 +36,8 @@ public: AudioStreamInfo &streamInfo, bool isReloadProcess) = 0; virtual uint32_t GenerateSessionId() = 0; virtual int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config) = 0; + virtual void GetVoiceMuteState(uint32_t sessionId, bool &muteState) = 0; + virtual void RemoveVoiceMuteState(uint32_t sessionId) = 0; virtual ~ICoreServiceProvider() = default; }; diff --git a/services/audio_service/common/src/audio_stream_checker.cpp b/services/audio_service/common/src/audio_stream_checker.cpp index 5dd822e8acfaeabb40c361cdd36d73856662d08a..9347edec501c5fdd823b0bcbeaa757abd2776537 100644 --- a/services/audio_service/common/src/audio_stream_checker.cpp +++ b/services/audio_service/common/src/audio_stream_checker.cpp @@ -424,5 +424,11 @@ void AudioStreamChecker::SetVolume(float volume) streamConfig_.originalSessionId, curVolume_, volume); curVolume_ = volume; } + +float AudioStreamChecker::GetVolume() +{ + std::lock_guard lock(volumeLock_); + return curVolume_; +} } } diff --git a/services/audio_service/common/src/audio_stream_monitor.cpp b/services/audio_service/common/src/audio_stream_monitor.cpp index b76ba05fdaecff7379404904ca45cf5c3955bdb8..5c349bda34b03dda58c087f57d2db02fc9c2b4cd 100644 --- a/services/audio_service/common/src/audio_stream_monitor.cpp +++ b/services/audio_service/common/src/audio_stream_monitor.cpp @@ -96,7 +96,7 @@ int32_t AudioStreamMonitor::UnregisterAudioRendererDataTransferStateListener( void AudioStreamMonitor::OnCallback(int32_t pid, int32_t callbackId, const AudioRendererDataTransferStateChangeInfo &info) { - std::lock_guard lock(regStatusMutex_); + std::lock_guard lock(callbackMutex_); if (audioServer_ == nullptr) { return; } @@ -108,7 +108,7 @@ void AudioStreamMonitor::OnCallback(int32_t pid, int32_t callbackId, void AudioStreamMonitor::OnMuteCallback(const int32_t &pid, const int32_t &callbackId, const int32_t &uid, const uint32_t &sessionId, const bool &isMuted) { - std::lock_guard lock(regStatusMutex_); + std::lock_guard lock(callbackMutex_); if (audioServer_ == nullptr) { return; } @@ -119,7 +119,7 @@ void AudioStreamMonitor::OnMuteCallback(const int32_t &pid, const int32_t &callb void AudioStreamMonitor::SetAudioServerPtr(DataTransferStateChangeCallbackForMonitor *ptr) { - std::lock_guard lock(regStatusMutex_); + std::lock_guard lock(callbackMutex_); audioServer_ = ptr; } @@ -196,5 +196,16 @@ void AudioStreamMonitor::UpdateMonitorVolume(const uint32_t &sessionId, const fl iter->second->SetVolume(volume); } } + +int32_t AudioStreamMonitor::GetVolumeBySessionId(const uint32_t &sessionId, float &volume) +{ + std::lock_guard lock(regStatusMutex_); + auto iter = audioStreamCheckers_.find(sessionId); + if (iter != audioStreamCheckers_.end()) { + volume = iter->second->GetVolume(); + return SUCCESS; + } + return ERR_UNKNOWN; +} } } \ No newline at end of file diff --git a/services/audio_service/common/src/audio_volume.cpp b/services/audio_service/common/src/audio_volume.cpp index e74d53571b530a60c0bf0f77886d3b55656154dd..6013976bf38f28666ddb49450f05a23401b9074c 100644 --- a/services/audio_service/common/src/audio_volume.cpp +++ b/services/audio_service/common/src/audio_volume.cpp @@ -676,6 +676,21 @@ int32_t AudioVolume::GetOffloadType(uint32_t streamIndex) AUDIO_WARNING_LOG("No such streamIndex in map!"); return OFFLOAD_DEFAULT; } + +void AudioVolume::SetOffloadEnable(uint32_t streamIndex, int32_t offloadEnable) +{ + std::unique_lock lock(fadeoutMutex_); + offloadEnable_.insert_or_assign(streamIndex, offloadEnable); +} + +int32_t AudioVolume::GetOffloadEnable(uint32_t streamIndex) +{ + std::shared_lock lock(fadeoutMutex_); + auto it = offloadEnable_.find(streamIndex); + if (it != offloadEnable_.end()) { return it->second; } + AUDIO_WARNING_LOG("No such streamIndex in map!"); + return 0; +} } // namespace AudioStandard } // namespace OHOS @@ -776,6 +791,16 @@ int32_t GetOffloadType(uint32_t streamIndex) { return AudioVolume::GetInstance()->GetOffloadType(streamIndex); } + +void SetOffloadEnable(uint32_t streamIndex, int32_t offloadEnable) +{ + AudioVolume::GetInstance()->SetOffloadEnable(streamIndex, offloadEnable); +} + +int32_t GetOffloadEnable(uint32_t streamIndex) +{ + return AudioVolume::GetInstance()->GetOffloadEnable(streamIndex); +} #ifdef __cplusplus } #endif \ No newline at end of file diff --git a/services/audio_service/idl/ICoreServiceProviderIpc.idl b/services/audio_service/idl/ICoreServiceProviderIpc.idl index 16dec65f261ee4dcb0ac4137ddb6d7bd70837c3a..cb65f621204d60ffc0204955c42fd817cb4290c6 100644 --- a/services/audio_service/idl/ICoreServiceProviderIpc.idl +++ b/services/audio_service/idl/ICoreServiceProviderIpc.idl @@ -44,4 +44,9 @@ interface ICoreServiceProviderIpc { void SetWakeUpAudioCapturerFromAudioServer( [in] AudioProcessConfig config, [out] int ret); + void GetVoiceMuteState( + [in] unsigned int sessionId, + [out] boolean muteState); + void RemoveVoiceMuteState( + [in] unsigned int sessionId); } diff --git a/services/audio_service/idl/IStandardAudioService.idl b/services/audio_service/idl/IStandardAudioService.idl index 491bfeaa64d9bbc302ddcb2f963eff5f2cc4b582..a63f46cd97b5e9b3a3ce818ee73b37285874c093 100644 --- a/services/audio_service/idl/IStandardAudioService.idl +++ b/services/audio_service/idl/IStandardAudioService.idl @@ -32,6 +32,7 @@ sequenceable audio_effect..OHOS.AudioStandard.AudioEnhancePropertyArray; sequenceable hdi_adapter_type..OHOS.AudioStandard.IAudioSinkAttr; sequenceable hdi_adapter_type..OHOS.AudioStandard.IAudioSourceAttr; sequenceable audio_stutter..OHOS.AudioStandard.DataTransferMonitorParam; +sequenceable audio_interrupt_info..OHOS.AudioStandard.InterruptEventInternal; interface IStandardAudioService { [ipccode 0] void GetAudioParameter([in] String key, [out] String value); @@ -138,9 +139,11 @@ interface IStandardAudioService { [oneway] void ImproveAudioWorkgroupPrio([in] int pid, [in] Map threads); void RestoreAudioWorkgroupPrio([in] int pid, [in] Map threads); void SetRenderWhitelist([in] List list); + void GetVolumeBySessionId([in] unsigned int sessionId, [out] float volume); // WARNING: above functions correspond with AudioServerInterfaceCode // undefined in AudioServerInterfaceCode [ipccode 1000] void SetForegroundList([in] List list); void GetVolumeDataCount([in] String sinkName, [out] long ret); + void SendInterruptEventToAudioServer([in] unsigned int sessionId, [in] InterruptEventInternal interruptEvent); } diff --git a/services/audio_service/libaudio_process_service.versionscript b/services/audio_service/libaudio_process_service.versionscript index 5ab9e8992aabb89142dfbdfa3c26e19629f7c3ce..056d705215d7b52c7c2c1c4eb747c38d003e8475 100644 --- a/services/audio_service/libaudio_process_service.versionscript +++ b/services/audio_service/libaudio_process_service.versionscript @@ -80,6 +80,10 @@ *SaveRenderWhitelist*; *InRenderWhitelist*; *HpaeCapturerStreamImpl*; + *UpdateSwitchStreamMap*; + *UpdateBackgroundCaptureMap*; + *SendInterruptEventToAudioServer*; + *SendInterruptEventToAudioService*; local: *; }; \ No newline at end of file diff --git a/services/audio_service/server/include/audio_resource_service.h b/services/audio_service/server/include/audio_resource_service.h index 9f7ecfb0cbacdd8d3a6587f550f0a129c1875873..e762e7348ab8e11f9470d44c5a0bb76186b483b3 100644 --- a/services/audio_service/server/include/audio_resource_service.h +++ b/services/audio_service/server/include/audio_resource_service.h @@ -21,7 +21,9 @@ #include #include #include - + +#include "iremote_object.h" + #include "audio_workgroup.h" #include "audio_common_log.h" #include "audio_stream_info.h" diff --git a/services/audio_service/server/include/audio_server.h b/services/audio_service/server/include/audio_server.h index d282d6000d2005f453cacbb5eb737689af160c1f..70a022a37022b364cd4da2684e1dd766662dcd21 100644 --- a/services/audio_service/server/include/audio_server.h +++ b/services/audio_service/server/include/audio_server.h @@ -267,6 +267,9 @@ public: void OnMuteStateChange(const int32_t &pid, const int32_t &callbackId, const int32_t &uid, const uint32_t &sessionId, const bool &isMuted) override; int32_t SetBtHdiInvalidState() override; + int32_t SendInterruptEventToAudioServer(uint32_t sessionId, + const InterruptEventInternal &interruptEvent) override; + int32_t GetVolumeBySessionId(uint32_t sessionId, float &volume) override; protected: void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; diff --git a/services/audio_service/server/include/audio_service.h b/services/audio_service/server/include/audio_service.h index d555df47b4b433e8febe6344f445cdb747fcda21..06d170252bb64cfa2f91d3de2154164ee5d539f1 100644 --- a/services/audio_service/server/include/audio_service.h +++ b/services/audio_service/server/include/audio_service.h @@ -141,7 +141,25 @@ public: int32_t UnloadModernInnerCapSink(int32_t innerCapId); #endif void RenderersCheckForAudioWorkgroup(int32_t pid); + void SendInterruptEventToAudioService(uint32_t sessionId, InterruptEventInternal interruptEvent); + bool UpdateResumeInterruptEventMap(uint32_t sessionId, InterruptEventInternal interruptEvent); + bool RemoveResumeInterruptEventMap(uint32_t sessionId); + bool IsStreamInterruptResume(uint32_t sessionId); + + bool UpdatePauseInterruptEventMap(uint32_t sessionId, InterruptEventInternal interruptEvent); + bool RemovePauseInterruptEventMap(uint32_t sessionId); + bool IsStreamInterruptPause(uint32_t sessionId); + + bool IsInSwitchStreamMap(uint32_t sessionId, SwitchState &switchState); + bool UpdateSwitchStreamMap(uint32_t sessionId, SwitchState switchState); + void RemoveSwitchStreamMap(uint32_t sessionId); + + bool IsBackgroundCaptureAllowed(uint32_t sessionId); + bool UpdateBackgroundCaptureMap(uint32_t sessionId, bool res); + void RemoveBackgroundCaptureMap(uint32_t sessionId); + bool NeedRemoveBackgroundCaptureMap(uint32_t sessionId); + private: AudioService(); void DelayCallReleaseEndpoint(std::string endpointName); @@ -181,11 +199,19 @@ private: bool IsMuteSwitchStream(uint32_t sessionId); float GetSystemVolume(); void UpdateSystemVolume(AudioStreamType streamType, float volume); - + void UpdateSessionMuteStatus(const uint32_t sessionId, const bool muteFlag); private: std::mutex foregroundSetMutex_; std::set foregroundSet_; std::set foregroundUidSet_; + std::mutex audioSwitchStreamMutex_; + std::map audioSwitchStreamMap_; + std::mutex backgroundCaptureMutex_; + std::map backgroundCaptureMap_; + std::mutex resumeInterruptEventMutex_; + std::map resumeInterruptEventMap_; + std::mutex pauseInterruptEventMutex_; + std::map pauseInterruptEventMap_; std::mutex processListMutex_; std::mutex releaseEndpointMutex_; std::condition_variable releaseEndpointCV_; diff --git a/services/audio_service/server/include/capturer_in_server.h b/services/audio_service/server/include/capturer_in_server.h index 25918ca91d8c7603473b9aa13bff1c5d195f1d22..9dca6a3767ab352dbebeda2c1a6310569c45e63e 100644 --- a/services/audio_service/server/include/capturer_in_server.h +++ b/services/audio_service/server/include/capturer_in_server.h @@ -79,6 +79,7 @@ private: void HandleOperationStopped(CapturerStage stage); void UpdateBufferTimeStamp(size_t readLen); inline void CaptureConcurrentCheck(uint32_t streamIndex); + void MuteVoice(const SourceType sourceType, BufferDesc &dstBuffer); std::mutex statusLock_; std::condition_variable statusCv_; diff --git a/services/audio_service/server/include/core_service_handler.h b/services/audio_service/server/include/core_service_handler.h index 8d729e5b217af5ccda6cc8ccdcf5264d6a0940e0..5d36653046c4895ca5aa33eca976cf2c9a10fced 100644 --- a/services/audio_service/server/include/core_service_handler.h +++ b/services/audio_service/server/include/core_service_handler.h @@ -46,6 +46,8 @@ public: AudioStreamInfo &streamInfo, bool isReloadProcess); uint32_t GenerateSessionId(); int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config); + int32_t GetVoiceMuteState(uint32_t sessionId, bool &muteState); + int32_t RemoveVoiceMuteState(uint32_t sessionId); private: CoreServiceHandler(); sptr iCoreServiceProvider_ = nullptr; diff --git a/services/audio_service/server/src/audio_endpoint.cpp b/services/audio_service/server/src/audio_endpoint.cpp index 61f3ac7e9167cba450f899604509b50f2b9b78b6..06167b4870c866b833a7fddd92e83fe6696499da 100644 --- a/services/audio_service/server/src/audio_endpoint.cpp +++ b/services/audio_service/server/src/audio_endpoint.cpp @@ -2300,11 +2300,13 @@ void AudioEndpointInner::ReportDataToResSched(std::unordered_mapGetDupRingBuffer() != nullptr) { - AUDIO_INFO_LOG("dup buffer already configed!"); - return SUCCESS; - } + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_.find(innerCapId) != + innerCapIdToDupStreamCallbackMap_.end(), SUCCESS, + "innerCapIdToDupStreamCallbackMap_ is no find innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId] != nullptr, + SUCCESS, "innerCapIdToDupStreamCallbackMap_ is null, innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() == nullptr, + SUCCESS, "DupRingBuffer not null, no need CreateDupBuffer, innerCapId: %{public}d", innerCapId); auto &capInfo = fastCaptureInfos_[innerCapId]; @@ -2338,10 +2340,13 @@ int32_t AudioEndpointInner::WriteDupBufferInner(const BufferDesc &bufferDesc, in { size_t targetSize = bufferDesc.bufLength; - if (innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() == nullptr) { - AUDIO_INFO_LOG("dup buffer is nnullptr, failed WriteDupBuffer!"); - return ERROR; - } + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_.find(innerCapId) != + innerCapIdToDupStreamCallbackMap_.end(), ERROR, + "innerCapIdToDupStreamCallbackMap_ is no find innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId] != nullptr, + ERROR, "innerCapIdToDupStreamCallbackMap_ is null, innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() != nullptr, + ERROR, "DupRingBuffe is null, innerCapId: %{public}d", innerCapId); OptResult result = innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer()->GetWritableSize(); // todo get writeable size failed CHECK_AND_RETURN_RET_LOG(result.ret == OPERATION_SUCCESS, ERROR, diff --git a/services/audio_service/server/src/audio_process_in_server.cpp b/services/audio_service/server/src/audio_process_in_server.cpp index 6249face778fd29da243b3a26658f9bd3c4ca3da..fe5501d79a459edb3ce59d4748e91bcacafe0e3c 100644 --- a/services/audio_service/server/src/audio_process_in_server.cpp +++ b/services/audio_service/server/src/audio_process_in_server.cpp @@ -206,9 +206,15 @@ bool AudioProcessInServer::CheckBGCapturer() uint64_t fullTokenId = processConfig_.appInfo.appFullTokenId; if (PermissionUtil::VerifyBackgroundCapture(tokenId, fullTokenId)) { + AudioService::GetInstance()->UpdateBackgroundCaptureMap(sessionId_, true); return true; } + if (AudioService::GetInstance()->IsStreamInterruptResume(sessionId_) && + AudioService::GetInstance()->IsBackgroundCaptureAllowed(sessionId_)) { + AUDIO_WARNING_LOG("Stream:%{public}u Result:success Reason:resume", sessionId_); + return true; + } CHECK_AND_RETURN_RET_LOG(processConfig_.capturerInfo.sourceType == SOURCE_TYPE_VOICE_COMMUNICATION && AudioService::GetInstance()->InForegroundList(processConfig_.appInfo.appUid), false, "Verify failed"); @@ -231,19 +237,19 @@ bool AudioProcessInServer::TurnOnMicIndicator(CapturerState capturerState) tokenId, capturerState, }; - if (!SwitchStreamUtil::IsSwitchStreamSwitching(info, SWITCH_STATE_STARTED)) { + if (SwitchStreamUtil::IsSwitchStreamSwitching(info, SWITCH_STATE_STARTED)) { + AudioService::GetInstance()->UpdateSwitchStreamMap(sessionId_, SWITCH_STATE_STARTED); + } else { CHECK_AND_RETURN_RET_LOG(CheckBGCapturer(), false, "Verify failed"); } SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_STARTED); if (isMicIndicatorOn_) { - AUDIO_WARNING_LOG("MicIndicator of stream:%{public}d is already on." - "No need to call NotifyPrivacyStart!", sessionId_); + AUDIO_WARNING_LOG("MicIndicator：already on, Stream:%{public}u.", sessionId_); } else { CHECK_AND_RETURN_RET_LOG(PermissionUtil::NotifyPrivacyStart(tokenId, sessionId_), false, "NotifyPrivacyStart failed!"); - AUDIO_INFO_LOG("Turn on micIndicator of stream:%{public}d from off " - "after NotifyPrivacyStart success!", sessionId_); + AUDIO_INFO_LOG("MicIndicator:turn on，Stream:%{public}u", sessionId_); isMicIndicatorOn_ = true; } return true; @@ -262,13 +268,15 @@ bool AudioProcessInServer::TurnOffMicIndicator(CapturerState capturerState) }; SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_FINISHED); + if (AudioService::GetInstance()->NeedRemoveBackgroundCaptureMap(sessionId_)) { + AudioService::GetInstance()->RemoveBackgroundCaptureMap(sessionId_); + } if (isMicIndicatorOn_) { PermissionUtil::NotifyPrivacyStop(tokenId, sessionId_); - AUDIO_INFO_LOG("Turn off micIndicator of stream:%{public}d from on after NotifyPrivacyStop!", sessionId_); + AUDIO_INFO_LOG("MicIndicator:turn off, Stream:%{public}u", sessionId_); isMicIndicatorOn_ = false; } else { - AUDIO_WARNING_LOG("MicIndicator of stream:%{public}d is already off." - "No need to call NotifyPrivacyStop!", sessionId_); + AUDIO_WARNING_LOG("MicIndicator:already off, Stream:%{public}u", sessionId_); } return true; } @@ -834,9 +842,9 @@ RestoreStatus AudioProcessInServer::RestoreSession(RestoreInfo restoreInfo) processConfig_.appInfo.appTokenId, HandleStreamStatusToCapturerState(streamStatus_->load()) }; - AUDIO_INFO_LOG("Insert fast record stream:%{public}u uid:%{public}d tokenId:%{public}u " - "into switchStreamRecord because restoreStatus:NEED_RESTORE", - sessionId_, info.callerUid, info.appTokenId); + AUDIO_INFO_LOG("Insert switchStream:%{public}u uid:%{public}d tokenId:%{public}u " + "Reason:NEED_RESTORE", sessionId_, info.callerUid, info.appTokenId); + AudioService::GetInstance()->UpdateSwitchStreamMap(sessionId_, SWITCH_STATE_WAITING); SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_WAITING); } diff --git a/services/audio_service/server/src/audio_server.cpp b/services/audio_service/server/src/audio_server.cpp index f7db6667a10b24fd6d1ef2acc2becac60c9fd956..5a4e81ba44499bc14717e25a12d30deeb5f26a51 100644 --- a/services/audio_service/server/src/audio_server.cpp +++ b/services/audio_service/server/src/audio_server.cpp @@ -239,6 +239,10 @@ static void SetAudioSceneForAllSource(AudioScene audioScene) if (primarySource != nullptr && primarySource->IsInited()) { primarySource->SetAudioScene(audioScene); } + std::shared_ptr aiSource = GetSourceByProp(HDI_ID_TYPE_AI); + if (aiSource != nullptr && aiSource->IsInited()) { + aiSource->SetAudioScene(audioScene); + } #ifdef SUPPORT_LOW_LATENCY std::shared_ptr fastSource = GetSourceByProp(HDI_ID_TYPE_FAST, HDI_ID_INFO_DEFAULT, true); if (fastSource != nullptr && fastSource->IsInited()) { @@ -284,6 +288,10 @@ static void UpdateDeviceForAllSource(std::shared_ptr &sourc fastVoipSource->UpdateActiveDevice(type); } #endif + std::shared_ptr aiSource = GetSourceByProp(HDI_ID_TYPE_AI, HDI_ID_INFO_DEFAULT); + if (aiSource != nullptr && aiSource->IsInited()) { + aiSource->UpdateActiveDevice(type); + } } // std::vector -> std::vector> @@ -344,6 +352,7 @@ public: { } +// LCOV_EXCL_START void OnCaptureState(bool isActive) override final { std::lock_guard lock(captureIdMtx_); @@ -358,6 +367,7 @@ public: captureId_, preNum, curNum, isActive); callback_(isActive, preNum, curNum); } +// LCOV_EXCL_STOP private: static inline std::unordered_set captureIds_; @@ -572,6 +582,7 @@ void DataTransferStateChangeCallbackInnerImpl::SetDataTransferMonitorParam( param_.badFramesRatio = param.badFramesRatio; } +// LCOV_EXCL_START void DataTransferStateChangeCallbackInnerImpl::OnDataTransferStateChange( const int32_t &callbackId, const AudioRendererDataTransferStateChangeInfo &info) { @@ -590,6 +601,7 @@ void DataTransferStateChangeCallbackInnerImpl::OnDataTransferStateChange( } } } +// LCOV_EXCL_STOP void DataTransferStateChangeCallbackInnerImpl::ReportEvent( const AudioRendererDataTransferStateChangeInfo &info) @@ -608,6 +620,7 @@ void DataTransferStateChangeCallbackInnerImpl::ReportEvent( Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean); } +// LCOV_EXCL_START void AudioServer::InitMaxRendererStreamCntPerUid() { bool result = GetSysPara("const.multimedia.audio.stream_cnt_uid", maxRendererStreamCntPerUid_); @@ -666,6 +679,7 @@ void AudioServer::OnStart() DlopenUtils::DeInit(); RegisterDataTransferStateChangeCallback(); } +// LCOV_EXCL_STOP void AudioServer::ParseAudioParameter() { @@ -818,6 +832,7 @@ bool AudioServer::ProcessKeyValuePairs(const std::string &key, return true; } +// LCOV_EXCL_START bool AudioServer::CacheExtraParameters(const std::string &key, const std::vector> &kvpairs) { @@ -851,6 +866,7 @@ void AudioServer::SetA2dpAudioParameter(const std::string &renderValue) AUDIO_INFO_LOG("HasBlueToothEndpoint"); } } +// LCOV_EXCL_STOP int32_t AudioServer::SetAudioParameter(const std::string &key, const std::string &value) { @@ -902,6 +918,8 @@ int32_t AudioServer::SetAudioParameter(const std::string &key, const std::string } else if (key == "mute_call") { deviceManager->SetAudioParameter("primary", parmKey, "", key + "=" + value); return SUCCESS; + } else if (key == "LOUD_VOLUMN_MODE") { + parmKey = AudioParamKey::NONE; } else { AUDIO_ERR_LOG("key %{public}s is invalid for hdi interface", key.c_str()); return SUCCESS; @@ -1396,6 +1414,7 @@ int32_t AudioServer::UpdateActiveDevicesRoute(const std::vector &active return SetIORoutes(activeOutputDevices, static_cast(a2dpOffloadFlag), deviceName); } +// LCOV_EXCL_START int32_t AudioServer::SetDmDeviceType(uint16_t dmDeviceType, int32_t deviceType) { int32_t callingUid = IPCSkeleton::GetCallingUid(); @@ -1847,6 +1866,7 @@ void AudioServer::NotifyProcessStatus() #endif } +// LCOV_EXCL_START int32_t AudioServer::CreateAudioProcess(const AudioProcessConfig &config, int32_t &errorCode, const AudioPlaybackCaptureConfig &filterConfig, sptr& client) { @@ -2286,8 +2306,8 @@ bool AudioServer::HandleCheckRecorderBackgroundCapture(const AudioProcessConfig CAPTURER_PREPARED, }; if (SwitchStreamUtil::IsSwitchStreamSwitching(info, SWITCH_STATE_CREATED)) { - AUDIO_INFO_LOG("Recreating stream for callerUid:%{public}d need not VerifyBackgroundCapture", - config.callerUid); + AUDIO_INFO_LOG("switchStream is recreating, callerUid:%{public}d", config.callerUid); + AudioService::GetInstance()->UpdateSwitchStreamMap(config.originalSessionId, SWITCH_STATE_CREATED); SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_CREATED); return true; } @@ -2314,6 +2334,15 @@ int32_t AudioServer::SetForegroundList(const std::vector &list) return SUCCESS; } +int32_t AudioServer::SendInterruptEventToAudioServer(uint32_t sessionId, const InterruptEventInternal &interruptEvent) +{ + int32_t callingUid = IPCSkeleton::GetCallingUid(); + CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifyIsAudio(), ERR_PERMISSION_DENIED, + "Refused for %{public}d", callingUid); + AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); + return SUCCESS; +} + int32_t AudioServer::SetRenderWhitelist(const std::vector &list) { CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifyIsAudio(), ERR_NOT_SUPPORTED, "refused for %{public}d", @@ -2322,6 +2351,13 @@ int32_t AudioServer::SetRenderWhitelist(const std::vector &list) return SUCCESS; } +int32_t AudioServer::GetVolumeBySessionId(uint32_t sessionId, float &volume) +{ + bool result = PermissionUtil::VerifySystemPermission(); + CHECK_AND_RETURN_RET_LOG(result, ERR_SYSTEM_PERMISSION_DENIED, "No system permission"); + return AudioStreamMonitor::GetInstance().GetVolumeBySessionId(sessionId, volume); +} + bool AudioServer::CheckVoiceCallRecorderPermission(Security::AccessToken::AccessTokenID tokenId) { bool hasRecordVoiceCallPermission = VerifyClientPermission(RECORD_VOICE_CALL_PERMISSION, tokenId); @@ -2396,6 +2432,10 @@ void AudioServer::RegisterAudioCapturerSourceCallback() if (type == HDI_ID_TYPE_BLUETOOTH) { return info == HDI_ID_INFO_DEFAULT; } + + if (type == HDI_ID_TYPE_AI) { + return info == HDI_ID_INFO_DEFAULT; + } return false; }; std::function(uint32_t)> callbackGenerator = [this](uint32_t captureId) -> @@ -2815,6 +2855,7 @@ int32_t AudioServer::SetInnerCapLimit(uint32_t innerCapLimit) } // LCOV_EXCL_STOP +// LCOV_EXCL_START int32_t AudioServer::ReleaseCaptureLimit(int32_t innerCapId) { #if defined(AUDIO_BUILD_VARIANT_ROOT) && defined(HAS_FEATURE_INNERCAPTURER) @@ -3075,5 +3116,6 @@ int32_t AudioServer::RestoreAudioWorkgroupPrio(int32_t pid, const std::unordered { return AudioResourceService::GetInstance()->RestoreAudioWorkgroupPrio(pid, threads); } +// LCOV_EXCL_STOP } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/server/src/audio_service.cpp b/services/audio_service/server/src/audio_service.cpp index 342d4b070acee408aaa13ce698fbfcf5e0e49768..a3499688678ba778e7eba9827aef8aab86e332c0 100644 --- a/services/audio_service/server/src/audio_service.cpp +++ b/services/audio_service/server/src/audio_service.cpp @@ -54,6 +54,7 @@ static const int32_t MEDIA_SERVICE_UID = 1013; static const int32_t RENDERER_STREAM_CNT_PER_UID_LIMIT = 40; static const int32_t INVALID_APP_UID = -1; static const int32_t INVALID_APP_CREATED_AUDIO_STREAM_NUM = 0; +static const uint32_t BACKGROUND_CAPTURE_INTERRUPT_TIMEOUT_SEC = 2; //2s namespace { static inline const std::unordered_set specialSourceTypeSet_ = { SOURCE_TYPE_PLAYBACK_CAPTURE, @@ -343,6 +344,188 @@ bool AudioService::InForegroundList(uint32_t uid) return false; } +void AudioService::SendInterruptEventToAudioService(uint32_t sessionId, + InterruptEventInternal interruptEvent) +{ + interruptEvent.eventTimestamp = ClockTime::GetCurNano(); + AUDIO_INFO_LOG("Recive InterruptEvent:[%{public}d] from InterruptService", interruptEvent.hintType); + if (interruptEvent.hintType == INTERRUPT_HINT_RESUME) { + UpdateResumeInterruptEventMap(sessionId, interruptEvent); + } + if (interruptEvent.hintType == INTERRUPT_HINT_PAUSE) { + UpdatePauseInterruptEventMap(sessionId, interruptEvent); + } +} + +bool AudioService::UpdateResumeInterruptEventMap(const uint32_t sessionId, + InterruptEventInternal interruptEvent) +{ + std::lock_guard lock(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + if (iter == resumeInterruptEventMap_.end()) { + resumeInterruptEventMap_[sessionId] = interruptEvent; + } else { + iter->second = interruptEvent; + } + return true; +} + +bool AudioService::RemoveResumeInterruptEventMap(const uint32_t sessionId) +{ + std::lock_guard lock(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + if (iter == resumeInterruptEventMap_.end()) { + return false; + } + resumeInterruptEventMap_.erase(sessionId); + return true; +} + +bool AudioService::IsStreamInterruptResume(const uint32_t sessionId) +{ + InterruptEventInternal interruptEvent; + std::lock_guard lock(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + if (iter == resumeInterruptEventMap_.end()) { + return false; + } + int64_t stamp = iter->second.eventTimestamp; + stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_NS_PER_SECOND; + if (stamp <= BACKGROUND_CAPTURE_INTERRUPT_TIMEOUT_SEC) { + AUDIO_WARNING_LOG("sessionId:%{public}u Resume Interrupt!!!", sessionId); + resumeInterruptEventMap_.erase(sessionId); + return true; + } + resumeInterruptEventMap_.erase(sessionId); + return false; +} + +bool AudioService::UpdatePauseInterruptEventMap(const uint32_t sessionId, + InterruptEventInternal interruptEvent) +{ + std::lock_guard lock(pauseInterruptEventMutex_); + auto iter = pauseInterruptEventMap_.find(sessionId); + if (iter == pauseInterruptEventMap_.end()) { + pauseInterruptEventMap_[sessionId] = interruptEvent; + } else { + iter->second = interruptEvent; + } + return true; +} + +bool AudioService::RemovePauseInterruptEventMap(const uint32_t sessionId) +{ + std::lock_guard lock(pauseInterruptEventMutex_); + auto iter = pauseInterruptEventMap_.find(sessionId); + if (iter == pauseInterruptEventMap_.end()) { + return false; + } + resumeInterruptEventMap_.erase(sessionId); + return true; +} + +bool AudioService::IsStreamInterruptPause(const uint32_t sessionId) +{ + std::lock_guard lock(pauseInterruptEventMutex_); + auto iter = pauseInterruptEventMap_.find(sessionId); + if (iter == pauseInterruptEventMap_.end()) { + return false; + } + int64_t stamp = iter->second.eventTimestamp; + stamp = (ClockTime::GetCurNano() - stamp) / AUDIO_NS_PER_SECOND; + if (stamp <= BACKGROUND_CAPTURE_INTERRUPT_TIMEOUT_SEC) { + AUDIO_WARNING_LOG("sessionId:%{public}u Pause Interrupt!!!", sessionId); + return true; + } + AUDIO_INFO_LOG("sessionId:%{public}u Pause Timeout!!!", sessionId); + return false; +} + +bool AudioService::IsInSwitchStreamMap(uint32_t sessionId, SwitchState &switchState) +{ + std::lock_guard lock(audioSwitchStreamMutex_); + switchState = SWITCH_STATE_FINISHED; + auto iter = audioSwitchStreamMap_.find(sessionId); + CHECK_AND_RETURN_RET_LOG(iter != audioSwitchStreamMap_.end(), false, + "can not find switchStream:%{public}u", sessionId); + switchState = iter->second; + return true; +} + +bool AudioService::UpdateSwitchStreamMap(uint32_t sessionId, SwitchState switchState) +{ + std::lock_guard lock(audioSwitchStreamMutex_); + auto iter = audioSwitchStreamMap_.find(sessionId); + if (iter == audioSwitchStreamMap_.end()) { + audioSwitchStreamMap_[sessionId] = switchState; + return true; + } + iter->second = switchState; + return true; +} + +void AudioService::RemoveSwitchStreamMap(uint32_t sessionId) +{ + std::lock_guard lock(audioSwitchStreamMutex_); + auto iter = audioSwitchStreamMap_.find(sessionId); + if (iter != audioSwitchStreamMap_.end()) { + audioSwitchStreamMap_.erase(sessionId); + } +} + +bool AudioService::IsBackgroundCaptureAllowed(uint32_t sessionId) +{ + std::lock_guard lock(backgroundCaptureMutex_); + auto iter = backgroundCaptureMap_.find(sessionId); + if (iter == backgroundCaptureMap_.end()) { + return false; + } + if (iter->second) { + AUDIO_WARNING_LOG("sessionId:%{public}u lastBackCap: success", sessionId); + return true; + } + return false; +} + +bool AudioService::UpdateBackgroundCaptureMap(uint32_t sessionId, bool res) +{ + std::lock_guard lock(backgroundCaptureMutex_); + auto iter = backgroundCaptureMap_.find(sessionId); + if (iter == backgroundCaptureMap_.end()) { + backgroundCaptureMap_[sessionId] = res; + return true; + } + iter->second = res; + return true; +} + +void AudioService::RemoveBackgroundCaptureMap(uint32_t sessionId) +{ + std::lock_guard lock(backgroundCaptureMutex_); + auto iter = backgroundCaptureMap_.find(sessionId); + if (iter != backgroundCaptureMap_.end()) { + audioSwitchStreamMap_.erase(sessionId); + } +} + +bool AudioService::NeedRemoveBackgroundCaptureMap(uint32_t sessionId) +{ + SwitchState switchState; + if (IsInSwitchStreamMap(sessionId, switchState)) { + if (switchState == SWITCH_STATE_WAITING) { + AUDIO_WARNING_LOG("SwitchStream should not reset"); + return false; + } + RemoveSwitchStreamMap(sessionId); + } + if (IsStreamInterruptPause(sessionId)) { + AUDIO_WARNING_LOG ("Pause Intertrupt Event need not reset"); + RemovePauseInterruptEventMap(sessionId); + return false; + } + return true; +} + void AudioService::SaveRenderWhitelist(std::vector list) { std::lock_guard lock(renderWhitelistMutex_); @@ -1238,6 +1421,7 @@ void AudioService::SetNonInterruptMute(const uint32_t sessionId, const bool mute } renderer->SetNonInterruptMute(muteFlag); AUDIO_INFO_LOG("allRendererMap_ has sessionId"); + UpdateSessionMuteStatus(sessionId, muteFlag); rendererLock.unlock(); return; } @@ -1251,6 +1435,7 @@ void AudioService::SetNonInterruptMute(const uint32_t sessionId, const bool mute } capturer->SetNonInterruptMute(muteFlag); AUDIO_INFO_LOG("allCapturerMap_ has sessionId"); + UpdateSessionMuteStatus(sessionId, muteFlag); return; } capturerLock.unlock(); @@ -1286,6 +1471,11 @@ void AudioService::SetNonInterruptMuteForProcess(const uint32_t sessionId, const // this sessionid will not add into mutedSessions_ // so need save it temporarily, when new stream create, check if new stream need mute // if set muteflag 0 again before new stream create, do not mute it + UpdateSessionMuteStatus(sessionId, muteFlag); +} + +void AudioService::UpdateSessionMuteStatus(const uint32_t sessionId, const bool muteFlag) +{ std::lock_guard muteSwitchStreamLock(muteSwitchStreamSetMutex_); if (muteFlag) { muteSwitchStreams_.insert(sessionId); diff --git a/services/audio_service/server/src/capturer_in_server.cpp b/services/audio_service/server/src/capturer_in_server.cpp index c11a7327a6bb4670b7b9f7047152e7a9a63821f5..2dc078a69962061b818a65cf29a94e0b27b2ef78 100644 --- a/services/audio_service/server/src/capturer_in_server.cpp +++ b/services/audio_service/server/src/capturer_in_server.cpp @@ -168,6 +168,7 @@ int32_t CapturerInServer::Init() return SUCCESS; } +// LCOV_EXCL_START void CapturerInServer::OnStatusUpdate(IOperation operation) { AUDIO_INFO_LOG("CapturerInServer::OnStatusUpdate operation: %{public}d", operation); @@ -211,6 +212,7 @@ void CapturerInServer::OnStatusUpdate(IOperation operation) CaptureConcurrentCheck(streamIndex_); } +// LCOV_EXCL_STOP void CapturerInServer::HandleOperationFlushed() { @@ -239,6 +241,7 @@ BufferDesc CapturerInServer::DequeueBuffer(size_t length) return stream_->DequeueBuffer(length); } +// LCOV_EXCL_START bool CapturerInServer::IsReadDataOverFlow(size_t length, uint64_t currentWriteFrame, std::shared_ptr stateListener) { @@ -259,6 +262,7 @@ bool CapturerInServer::IsReadDataOverFlow(size_t length, uint64_t currentWriteFr } return false; } +// LCOV_EXCL_STOP static CapturerState HandleStreamStatusToCapturerState(const IStatus &status) @@ -286,6 +290,7 @@ static CapturerState HandleStreamStatusToCapturerState(const IStatus &status) } } +// LCOV_EXCL_START static uint32_t GetByteSizeByFormat(enum AudioSampleFormat format) { uint32_t byteSize = 0; @@ -311,6 +316,7 @@ static uint32_t GetByteSizeByFormat(enum AudioSampleFormat format) } return byteSize; } +// LCOV_EXCL_STOP void CapturerInServer::UpdateBufferTimeStamp(size_t readLen) { @@ -330,6 +336,20 @@ void CapturerInServer::UpdateBufferTimeStamp(size_t readLen) audioServerBuffer_->SetTimeStampInfo(curProcessPos_, timestamp); } +void CapturerInServer::MuteVoice(const SourceType sourceType, BufferDesc &dstBuffer) +{ + bool muteState = false; + if (CoreServiceHandler::GetInstance().GetVoiceMuteState(streamIndex_, muteState)) { + if (muteState) { + AUDIO_DEBUG_LOG("session:%{public}d muted", streamIndex_); + int32_t ret = memset_s(static_cast(dstBuffer.buffer), dstBuffer.bufLength, + 0, dstBuffer.bufLength); + CHECK_AND_RETURN_LOG(ret == EOK, "Clear buffer fail, ret %{public}d.", ret); + } + } +} + +// LCOV_EXCL_START void CapturerInServer::ReadData(size_t length) { CHECK_AND_RETURN_LOG(length >= spanSizeInBytes_, @@ -365,6 +385,9 @@ void CapturerInServer::ReadData(size_t length) LEGACY_MUTE_CAP) || muteFlag_) { dstBuffer.buffer = dischargeBuffer_.get(); // discharge valid data. } + + MuteVoice(processConfig_.capturerInfo.sourceType, dstBuffer); + if (muteFlag_) { memset_s(static_cast(dstBuffer.buffer), dstBuffer.bufLength, 0, dstBuffer.bufLength); } @@ -385,6 +408,7 @@ void CapturerInServer::ReadData(size_t length) stream_->EnqueueBuffer(srcBuffer); stateListener->OnOperationHandled(UPDATE_STREAM, currentWriteFrame); } +// LCOV_EXCL_STOP int32_t CapturerInServer::OnReadData(size_t length) { @@ -393,6 +417,7 @@ int32_t CapturerInServer::OnReadData(size_t length) return SUCCESS; } +// LCOV_EXCL_START int32_t CapturerInServer::OnReadData(int8_t *outputData, size_t requestDataLen) { CHECK_AND_RETURN_RET_LOG(status_.load() == I_STATUS_STARTED, ERR_READ_FAILED, "CapturerInServer is not started"); @@ -426,6 +451,9 @@ int32_t CapturerInServer::OnReadData(int8_t *outputData, size_t requestDataLen) LEGACY_MUTE_CAP) || muteFlag_) { dstBuffer.buffer = dischargeBuffer_.get(); // discharge valid data. } + + MuteVoice(processConfig_.capturerInfo.sourceType, dstBuffer); + if (muteFlag_) { memset_s(static_cast(dstBuffer.buffer), dstBuffer.bufLength, 0, dstBuffer.bufLength); } @@ -447,6 +475,7 @@ int32_t CapturerInServer::OnReadData(int8_t *outputData, size_t requestDataLen) return SUCCESS; } +// LCOV_EXCL_STOP int32_t CapturerInServer::UpdateReadIndex() { @@ -477,6 +506,13 @@ bool CapturerInServer::CheckBGCapture() uint64_t fullTokenId = processConfig_.appInfo.appFullTokenId; if (PermissionUtil::VerifyBackgroundCapture(tokenId, fullTokenId)) { + AudioService::GetInstance()->UpdateBackgroundCaptureMap(streamIndex_, true); + return true; + } + + if (AudioService::GetInstance()->IsStreamInterruptResume(streamIndex_) && + AudioService::GetInstance()->IsBackgroundCaptureAllowed(streamIndex_)) { + AUDIO_WARNING_LOG("Stream:%{public}u Result:success Reason:resume", streamIndex_); return true; } @@ -502,19 +538,19 @@ bool CapturerInServer::TurnOnMicIndicator(CapturerState capturerState) tokenId, capturerState, }; - if (!SwitchStreamUtil::IsSwitchStreamSwitching(info, SWITCH_STATE_STARTED)) { + if (SwitchStreamUtil::IsSwitchStreamSwitching(info, SWITCH_STATE_STARTED)) { + AudioService::GetInstance()->UpdateSwitchStreamMap(streamIndex_, SWITCH_STATE_STARTED); + } else { CHECK_AND_RETURN_RET_LOG(CheckBGCapture(), false, "Verify failed"); } SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_STARTED); if (isMicIndicatorOn_) { - AUDIO_WARNING_LOG("MicIndicator of stream:%{public}d is already on." - "No need to call NotifyPrivacyStart!", streamIndex_); + AUDIO_WARNING_LOG("MicIndicator：already on, Stream:%{public}u.", streamIndex_); } else { CHECK_AND_RETURN_RET_LOG(PermissionUtil::NotifyPrivacyStart(tokenId, streamIndex_), false, "NotifyPrivacyStart failed!"); - AUDIO_INFO_LOG("Turn on micIndicator of stream:%{public}d from off " - "after NotifyPrivacyStart success!", streamIndex_); + AUDIO_INFO_LOG("MicIndicator:turn on，Stream:%{public}u", streamIndex_); isMicIndicatorOn_ = true; } return true; @@ -533,13 +569,15 @@ bool CapturerInServer::TurnOffMicIndicator(CapturerState capturerState) }; SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_FINISHED); + if (AudioService::GetInstance()->NeedRemoveBackgroundCaptureMap(streamIndex_)) { + AudioService::GetInstance()->RemoveBackgroundCaptureMap(streamIndex_); + } if (isMicIndicatorOn_) { PermissionUtil::NotifyPrivacyStop(tokenId, streamIndex_); - AUDIO_INFO_LOG("Turn off micIndicator of stream:%{public}d from on after NotifyPrivacyStop!", streamIndex_); + AUDIO_INFO_LOG("MicIndicator:turn off, Stream:%{public}u", streamIndex_); isMicIndicatorOn_ = false; } else { - AUDIO_WARNING_LOG("MicIndicator of stream:%{public}d is already off." - "No need to call NotifyPrivacyStop!", streamIndex_); + AUDIO_WARNING_LOG("MicIndicator:already off, Stream:%{public}u", streamIndex_); } return true; } @@ -560,6 +598,7 @@ int32_t CapturerInServer::Start() return ret; } +// LCOV_EXCL_START int32_t CapturerInServer::StartInner() { needStart = 0; @@ -602,7 +641,9 @@ int32_t CapturerInServer::StartInner() return SUCCESS; } +// LCOV_EXCL_STOP +// LCOV_EXCL_START int32_t CapturerInServer::Pause() { AudioXCollie audioXCollie( @@ -631,6 +672,7 @@ int32_t CapturerInServer::Pause() } return SUCCESS; } +// LCOV_EXCL_STOP int32_t CapturerInServer::Flush() { @@ -676,6 +718,7 @@ int32_t CapturerInServer::DrainAudioBuffer() return SUCCESS; } +// LCOV_EXCL_START int32_t CapturerInServer::Stop() { AudioXCollie audioXCollie( @@ -702,8 +745,10 @@ int32_t CapturerInServer::Stop() CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Stop stream failed, reason: %{public}d", ret); CoreServiceHandler::GetInstance().UpdateSessionOperation(streamIndex_, SESSION_OPERATION_STOP); StreamDfxManager::GetInstance().CheckStreamOccupancy(streamIndex_, processConfig_, false); + CoreServiceHandler::GetInstance().RemoveVoiceMuteState(streamIndex_); return SUCCESS; } +// LCOV_EXCL_STOP int32_t CapturerInServer::Release(bool isSwitchStream) { @@ -817,6 +862,7 @@ int32_t CapturerInServer::UpdatePlaybackCaptureConfig(const AudioPlaybackCapture } #endif +// LCOV_EXCL_START int32_t CapturerInServer::GetAudioTime(uint64_t &framePos, uint64_t ×tamp) { if (status_ == I_STATUS_STOPPED) { @@ -832,6 +878,7 @@ int32_t CapturerInServer::GetAudioTime(uint64_t &framePos, uint64_t ×tamp) } return SUCCESS; } +// LCOV_EXCL_STOP int32_t CapturerInServer::GetLatency(uint64_t &latency) { @@ -883,9 +930,9 @@ RestoreStatus CapturerInServer::RestoreSession(RestoreInfo restoreInfo) processConfig_.appInfo.appTokenId, HandleStreamStatusToCapturerState(status_) }; - AUDIO_INFO_LOG("Insert fast record stream:%{public}u uid:%{public}d tokenId:%{public}u " - "into switchStreamRecord because restoreStatus:NEED_RESTORE", - streamIndex_, info.callerUid, info.appTokenId); + AUDIO_INFO_LOG("Insert switchStream:%{public}u uid:%{public}d tokenId:%{public}u " + "Reason:NEED_RESTORE", streamIndex_, info.callerUid, info.appTokenId); + AudioService::GetInstance()->UpdateSwitchStreamMap(streamIndex_, SWITCH_STATE_WAITING); SwitchStreamUtil::UpdateSwitchStreamRecord(info, SWITCH_STATE_WAITING); audioServerBuffer_->SetRestoreInfo(restoreInfo); @@ -912,6 +959,7 @@ int32_t CapturerInServer::ResolveBufferBaseAndGetServerSpanSize(std::shared_ptr< return ERR_NOT_SUPPORTED; } +// LCOV_EXCL_START inline void CapturerInServer::CaptureConcurrentCheck(uint32_t streamIndex) { if (lastStatus_ == status_) { @@ -921,5 +969,6 @@ inline void CapturerInServer::CaptureConcurrentCheck(uint32_t streamIndex) int32_t ret = PolicyHandler::GetInstance().CaptureConcurrentCheck(streamIndex); AUDIO_INFO_LOG("ret:%{public}d streamIndex_:%{public}d status_:%{public}u", ret, streamIndex, status_.load()); } +// LCOV_EXCL_STOP } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/server/src/core_service_handler.cpp b/services/audio_service/server/src/core_service_handler.cpp index f3273c10a6bdc60baf567a891be67e025351d614..e5f14e8d8c2bab135a77c1027d9d4ff6f10cdb8f 100644 --- a/services/audio_service/server/src/core_service_handler.cpp +++ b/services/audio_service/server/src/core_service_handler.cpp @@ -106,5 +106,19 @@ int32_t CoreServiceHandler::SetWakeUpAudioCapturerFromAudioServer(const AudioPro iCoreServiceProvider_->SetWakeUpAudioCapturerFromAudioServer(config, ret); return ret; } + +int32_t CoreServiceHandler::GetVoiceMuteState(uint32_t sessionId, bool &muteState) +{ + CHECK_AND_RETURN_RET_LOG(iCoreServiceProvider_ != nullptr, ERROR, "iCoreServiceProvider_ is nullptr!"); + iCoreServiceProvider_->GetVoiceMuteState(sessionId, muteState); + return SUCCESS; +} + +int32_t CoreServiceHandler::RemoveVoiceMuteState(uint32_t sessionId) +{ + CHECK_AND_RETURN_RET_LOG(iCoreServiceProvider_ != nullptr, ERROR, "iCoreServiceProvider_ is nullptr!"); + iCoreServiceProvider_->RemoveVoiceMuteState(sessionId); + return SUCCESS; +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/server/src/pa_renderer_stream_impl.cpp b/services/audio_service/server/src/pa_renderer_stream_impl.cpp index 0e4ced3dbcbf1bef6c370b5e82524067d4bebc39..5991643c5aab0d28c6d676a6afb0ab2b83999434 100644 --- a/services/audio_service/server/src/pa_renderer_stream_impl.cpp +++ b/services/audio_service/server/src/pa_renderer_stream_impl.cpp @@ -1176,11 +1176,7 @@ int32_t PaRendererStreamImpl::OffloadUpdatePolicy(AudioOffloadType statePolicy, } pa_proplist *propList = pa_proplist_new(); CHECK_AND_RETURN_RET_LOG(propList != nullptr, ERR_OPERATION_FAILED, "pa_proplist_new failed"); - if (offloadEnable_) { - pa_proplist_sets(propList, "stream.offload.enable", "1"); - } else { - pa_proplist_sets(propList, "stream.offload.enable", "0"); - } + AudioVolume::GetInstance()->SetOffloadType(sinkInputIndex_, offloadEnable_); AudioVolume::GetInstance()->SetOffloadType(sinkInputIndex_, statePolicy); pa_operation *updatePropOperation = diff --git a/services/audio_service/server/src/renderer_in_server.cpp b/services/audio_service/server/src/renderer_in_server.cpp index 6acdb91a9b13ee0e13c69a0b5e4795343470ca61..70a59ae23e1928e453155c72d90f6eaf769e5624 100644 --- a/services/audio_service/server/src/renderer_in_server.cpp +++ b/services/audio_service/server/src/renderer_in_server.cpp @@ -831,7 +831,7 @@ void RendererInServer::InnerCaptureEnqueueBuffer(const BufferDesc &bufferDesc, C renderEmptyCountForInnerCap_ = 0; } if (engineFlag == 1) { - AUDIO_INFO_LOG("OtherStreamEnqueue running"); + AUDIO_DEBUG_LOG("OtherStreamEnqueue running"); WriteDupBufferInner(bufferDesc, innerCapId); } else { captureInfo.dupStream->EnqueueBuffer(bufferDesc); // what if enqueue fail? @@ -844,6 +844,8 @@ void RendererInServer::InnerCaptureOtherStream(const BufferDesc &bufferDesc, Cap if (captureInfo.isInnerCapEnabled) { Trace traceDup("RendererInServer::WriteData DupSteam write"); if (captureInfo.dupStream != nullptr) { + Trace trace("InnerCaptureOtherStream WriteData, sessionId: " + + std::to_string(captureInfo.dupStream->GetStreamIndex())); InnerCaptureEnqueueBuffer(bufferDesc, captureInfo, innerCapId); } } @@ -2114,12 +2116,13 @@ std::unique_ptr& RendererInServer::GetDupRingBuffer() int32_t RendererInServer::CreateDupBufferInner(int32_t innerCapId) { // todo dynamic - if (innerCapIdToDupStreamCallbackMap_.find(innerCapId) == innerCapIdToDupStreamCallbackMap_.end() || - innerCapIdToDupStreamCallbackMap_[innerCapId] == nullptr || - innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() != nullptr) { - AUDIO_INFO_LOG("dup buffer already configed!"); - return SUCCESS; - } + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_.find(innerCapId) != + innerCapIdToDupStreamCallbackMap_.end(), SUCCESS, + "innerCapIdToDupStreamCallbackMap_ is no find innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId] != nullptr, + SUCCESS, "innerCapIdToDupStreamCallbackMap_ is null, innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() == nullptr, + SUCCESS, "DupRingBuffer not null, no need CreateDupBuffer, innerCapId: %{public}d", innerCapId); auto &capInfo = captureInfos_[innerCapId]; capInfo.dupStream->GetSpanSizePerFrame(dupSpanSizeInFrame_); @@ -2151,12 +2154,13 @@ int32_t RendererInServer::CreateDupBufferInner(int32_t innerCapId) int32_t RendererInServer::WriteDupBufferInner(const BufferDesc &bufferDesc, int32_t innerCapId) { size_t targetSize = bufferDesc.bufLength; - if (innerCapIdToDupStreamCallbackMap_.find(innerCapId) == innerCapIdToDupStreamCallbackMap_.end() || - innerCapIdToDupStreamCallbackMap_[innerCapId] == nullptr || - innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() == nullptr) { - AUDIO_INFO_LOG("dup buffer is nnullptr, failed WriteDupBuffer!"); - return ERROR; - } + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_.find(innerCapId) != + innerCapIdToDupStreamCallbackMap_.end(), ERROR, + "innerCapIdToDupStreamCallbackMap_ is no find innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId] != nullptr, + ERROR, "innerCapIdToDupStreamCallbackMap_ is null, innerCapId: %{public}d", innerCapId); + CHECK_AND_RETURN_RET_LOG(innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer() != nullptr, + ERROR, "DupRingBuffe is null, innerCapId: %{public}d", innerCapId); OptResult result = innerCapIdToDupStreamCallbackMap_[innerCapId]->GetDupRingBuffer()->GetWritableSize(); // todo get writeable size failed CHECK_AND_RETURN_RET_LOG(result.ret == OPERATION_SUCCESS, ERROR, diff --git a/services/audio_service/test/unittest/BUILD.gn b/services/audio_service/test/unittest/BUILD.gn index f689b694983182b5f5ada9a8a9150927f1536205..cdc79b5ac9cbbf1f063489350f7cc7a834ced404 100644 --- a/services/audio_service/test/unittest/BUILD.gn +++ b/services/audio_service/test/unittest/BUILD.gn @@ -202,6 +202,39 @@ ohos_unittest("audio_thread_task_unit_test") { ] } +ohos_unittest("audio_ring_cache_unit_test") { + module_out_path = module_output_path + + install_enable = false + + include_dirs = [ + "../../../../frameworks/native/audioutils/include", + "../../../../interfaces/inner_api/native/audiocommon/include", + "../../../../services/audio_service/common/include", + "../../../../services/audio_service/server/include", + ] + + cflags = [ + "-DDEBUG_DIRECT_USE_HDI", + "-fno-access-control", + ] + + sources = [ "audio_ring_cache_unit_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "../../../../frameworks/native/audioutils:audio_utils", + "../../../../services/audio_service:audio_client", + "../../../../services/audio_service:audio_common", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] +} + ohos_unittest("audio_stream_checker_unit_test") { module_out_path = module_output_path diff --git a/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp b/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp index d4bdc5020bcd8f8a836d3039fc10c2bbf728e202..73a58f852b5a076c80755019da9f69606426b0ea 100644 --- a/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp @@ -1875,5 +1875,68 @@ HWTEST_F(AudioEndpointPlusUnitTest, ProcessToDupStream_001, TestSize.Level1) audioEndpointnIner->ProcessToDupStream(audioDataList, dstStreamData, innerCapId); EXPECT_EQ(innerCapId, 1); } + +/* + * @tc.name : Test ProcessToDupStream API + * @tc.type : FUNC + * @tc.number: HandleDisableFastCap_001 + * @tc.desc : Test AudioEndpointInner::HandleDisableFastCap() + */ +HWTEST_F(AudioEndpointPlusUnitTest, ProcessToDupStream_001, TestSize.Level1) +{ + AudioEndpoint::EndpointType type = AudioEndpoint::TYPE_MMAP; + uint64_t id = 123; + AudioProcessConfig clientConfig = {}; + auto audioEndpointInner = std::make_shared(type, id, clientConfig); + ASSERT_NE(audioEndpointInner, nullptr); + CaptureInfo captureInfo; + + EXPECT_EQ(audioEndpointInner->HandleDisableFastCap(captureInfo), SUCCESS); +} + +/* + * @tc.name : Test AudioEndpointInner API + * @tc.type : FUNC + * @tc.number: AudioEndpointInner_008 + * @tc.desc : Test AudioEndpointInner::HandleRendererDataParams() + */ +HWTEST_F(AudioEndpointPlusUnitTest, AudioEndpointInner_008, TestSize.Level1) +{ + AudioEndpoint::EndpointType type = AudioEndpoint::TYPE_MMAP; + uint64_t id = 123; + AudioProcessConfig clientConfig = {}; + auto audioEndpointInner = std::make_shared(type, id, clientConfig); + + ASSERT_NE(audioEndpointInner, nullptr); + + AudioStreamData srcData; + AudioStreamData dstData; + srcData.streamInfo.encoding = AudioEncodingType::ENCODING_PCM; + dstData.streamInfo.encoding = AudioEncodingType::ENCODING_PCM; + + srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE; + srcData.streamInfo.channels = AudioChannel::MONO; + audioEndpointInner->HandleRendererDataParams(srcData, dstData); + + srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE; + srcData.streamInfo.channels = AudioChannel::CHANNEL_3; + audioEndpointInner->HandleRendererDataParams(srcData, dstData); + + srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE; + srcData.streamInfo.channels = AudioChannel::MONO; + audioEndpointInner->HandleRendererDataParams(srcData, dstData); + + srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE; + srcData.streamInfo.channels = AudioChannel::STEREO; + audioEndpointInner->HandleRendererDataParams(srcData, dstData); + + srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE; + srcData.streamInfo.channels = AudioChannel::CHANNEL_3; + audioEndpointInner->HandleRendererDataParams(srcData, dstData); + + srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE; + srcData.streamInfo.channels = AudioChannel::CHANNEL_3; + audioEndpointInner->HandleRendererDataParams(srcData, dstData); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/audio_group_manager_unit_test.cpp b/services/audio_service/test/unittest/audio_group_manager_unit_test.cpp index e95f22514943bccb0c486015a69e387b13ab96f0..3547eb8ff675bc4dddef0b265394a28863d89f5e 100644 --- a/services/audio_service/test/unittest/audio_group_manager_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_group_manager_unit_test.cpp @@ -367,5 +367,88 @@ HWTEST(AudioGroupManagerUnitTest, AdjustVolumeByStep_001, TestSize.Level1) result = audioGroupManager.AdjustVolumeByStep(adjustType); EXPECT_NE(result, 0); } + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: SetVolume_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, SetVolume_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + int32_t ret = audioGroupManager.SetVolume(STREAM_ALL, 0, 0, 123); + EXPECT_EQ(ret, ERR_PERMISSION_DENIED); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: SetVolume_005 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, SetVolume_005, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + int32_t ret = audioGroupManager.SetVolume(STREAM_DEFAULT, 0, 0, 123); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: SetVolume_006 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, SetVolume_006, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; + int32_t ret = audioGroupManager.SetVolume(STREAM_DEFAULT, 0, 0, 123); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: GetVolume_005 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, GetVolume_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; + int32_t ret = audioGroupManager.GetVolume(STREAM_NOTIFICATION, 123); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: GetMaxVolume_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, GetMaxVolume_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; + int32_t ret = audioGroupManager.GetMaxVolume(STREAM_ULTRASONIC); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: IsStreamMute_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, IsStreamMute_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = ConnectType::CONNECT_TYPE_LOCAL; + bool isMute = false; + int32_t ret = audioGroupManager.IsStreamMute(AudioStreamType::STREAM_ALL, isMute); + EXPECT_EQ(ret, SUCCESS); +} } // namespace AudioStandard } // \ No newline at end of file diff --git a/services/audio_service/test/unittest/audio_process_in_server_unit_test.cpp b/services/audio_service/test/unittest/audio_process_in_server_unit_test.cpp index 9148d12214a9c4d2b9b03b2f6d9e3e2f9c61c0f8..e43d31f50e0774f89265104d37b45fb76b65e642 100644 --- a/services/audio_service/test/unittest/audio_process_in_server_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_process_in_server_unit_test.cpp @@ -1132,5 +1132,60 @@ HWTEST(AudioProcessInServerUnitTest, CheckBGCapturer_001, TestSize.Level4) EXPECT_FALSE(audioProcessInServerRet.CheckBGCapturer()); } + +/** + * @tc.name : Test GetByteSizePerFrame API + * @tc.type : FUNC + * @tc.number: GetByteSizePerFrame_001 + * @tc.desc : Test GetByteSizePerFrame interface. + */ +HWTEST(AudioProcessInServerUnitTest, GetByteSizePerFrame_001, TestSize.Level4) +{ + AudioProcessConfig configRet = InitProcessConfig(); + AudioService *releaseCallbackRet = AudioService::GetInstance(); + AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet); + audioProcessInServerRet.byteSizePerFrame_ = 10; + + uint32_t ret = audioProcessInServerRet.GetByteSizePerFrame(); + EXPECT_EQ(ret, audioProcessInServerRet.byteSizePerFrame_); +} + +/** + * @tc.name : Test RequestHandleInfoAsync API + * @tc.type : FUNC + * @tc.number: RequestHandleInfoAsync_001 + * @tc.desc : Test RequestHandleInfoAsync interface. + */ +HWTEST(AudioProcessInServerUnitTest, RequestHandleInfoAsync_001, TestSize.Level4) +{ + AudioProcessConfig configRet = InitProcessConfig(); + AudioService *releaseCallbackRet = AudioService::GetInstance(); + AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet); + audioProcessInServerRet.isInited_ = true; + AudioBufferHolder bufferHolder = AudioBufferHolder::AUDIO_SERVER_SHARED; + uint32_t byteSizePerFrame = 1000; + audioProcessInServerRet.processBuffer_ = std::make_shared(bufferHolder, + TOTAL_SIZE_IN_FRAME, byteSizePerFrame); + EXPECT_NE(audioProcessInServerRet.processBuffer_, nullptr); + auto ret = audioProcessInServerRet.RequestHandleInfoAsync(); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test GetSpanSizeInFrame API + * @tc.type : FUNC + * @tc.number: GetSpanSizeInFrame_001 + * @tc.desc : Test GetSpanSizeInFrame interface. + */ +HWTEST(AudioProcessInServerUnitTest, GetSpanSizeInFrame_001, TestSize.Level4) +{ + AudioProcessConfig configRet = InitProcessConfig(); + AudioService *releaseCallbackRet = AudioService::GetInstance(); + AudioProcessInServer audioProcessInServerRet(configRet, releaseCallbackRet); + audioProcessInServerRet.spanSizeInframe_ = 10; + + uint32_t ret = audioProcessInServerRet.GetSpanSizeInFrame(); + EXPECT_EQ(ret, audioProcessInServerRet.spanSizeInframe_); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp b/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp index e8a6f5a5cce00905889e23f257901d68fd7049bf..c2fbdbd32c487fb3e1d2a24b1a736c166eb6f04f 100644 --- a/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp @@ -56,6 +56,7 @@ AudioResourceService::AudioWorkgroupDeathRecipient deathRecipient; AudioResourceService audioResourceService; const int32_t testRtgId = 2; static constexpr int32_t AUDIO_MAX_PROCESS = 2; +static constexpr int32_t AUDIO_MAX_GRP_PER_PROCESS = 4; class RemoteObjectTestStub : public IRemoteObject { public: @@ -68,6 +69,11 @@ public: DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub"); }; +class DummyAudioWorkgroup : public AudioWorkgroup { +public: + explicit DummyAudioWorkgroup(int32_t groupId) : AudioWorkgroup(groupId) {} +}; + /** * @tc.name : Test deathRecipient * @tc.type : FUNC @@ -260,7 +266,7 @@ HWTEST(AudioResourceServiceUnitTest, RestoreAudioWorkgroupPrio_002, TestSize.Lev * @tc.name : Test AudioWorkgroupCheck * @tc.type : FUNC * @tc.number: AudioWorkgroupCheck - * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup + * @tc.desc : Test AudioWorkgroupCheck method with invalid and valid pid */ HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_001, TestSize.Level0) { @@ -277,7 +283,7 @@ HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_001, TestSize.Level0) * @tc.name : Test ReleaseAudioWorkgroup * @tc.type : FUNC * @tc.number: ReleaseAudioWorkgroup - * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup + * @tc.desc : Test ReleaseAudioWorkgroup method with invalid and valid pid */ HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_001, TestSize.Level0) { @@ -418,6 +424,26 @@ HWTEST(AudioResourceServiceUnitTest, StopGroup_001, TestSize.Level0) EXPECT_NE(ret, 0); } +/** + * @tc.name : StopGroup + * @tc.type : FUNC + * @tc.number: StopGroup_002 + * @tc.desc : Test that StopGroup executes Stop when group exists. + */ +HWTEST(AudioResourceServiceUnitTest, StopGroup_002, TestSize.Level1) +{ + AudioResourceService* service = AudioResourceService::GetInstance(); + int32_t pid = 55; + int32_t groupId = 66; + + std::shared_ptr workgroupPtr = std::make_shared(groupId); + service->audioWorkgroupMap_[pid].groups[groupId] = workgroupPtr; + + int32_t ret = service->StopGroup(pid, groupId); + + EXPECT_EQ(ret, AUDIO_ERR); +} + /** * @tc.name : Test IsProcessHasSystemPermission * @tc.type : FUNC @@ -522,6 +548,28 @@ HWTEST(AudioResourceServiceUnitTest, StartGroup_001, TestSize.Level0) EXPECT_EQ(ret, ERR_INVALID_PARAM); } +/** + * @tc.name : StartGroup + * @tc.type : FUNC + * @tc.number: StartGroup_002 + * @tc.desc : Test that StartGroup executes Start when group exists. + */ +HWTEST(AudioResourceServiceUnitTest, StartGroup_002, TestSize.Level1) +{ + AudioResourceService* service = AudioResourceService::GetInstance(); + int32_t pid = 101; + int32_t groupId = 202; + uint64_t startTime = 1000; + uint64_t deadlineTime = 2000; + + std::shared_ptr workgroupPtr = std::make_shared(groupId); + service->audioWorkgroupMap_[pid].groups[groupId] = workgroupPtr; + + int32_t ret = service->StartGroup(pid, groupId, startTime, deadlineTime); + + EXPECT_EQ(ret, AUDIO_ERR); +} + /** * @tc.name : Test RemoveThreadFromGroup * @tc.type : FUNC @@ -539,6 +587,28 @@ HWTEST(AudioResourceServiceUnitTest, RemoveThreadFromGroup_001, TestSize.Level0) EXPECT_EQ(ret, ERR_INVALID_PARAM); } +/** + * @tc.name : RemoveThreadFromGroup + * @tc.type : FUNC + * @tc.number: RemoveThreadFromGroup_002 + * @tc.desc : Test that RemoveThreadFromGroup executes RemoveThread when group exists. + */ +HWTEST(AudioResourceServiceUnitTest, RemoveThreadFromGroup_002, TestSize.Level1) +{ + AudioResourceService* service = AudioResourceService::GetInstance(); + int32_t pid = 1111; + int32_t groupId = 2222; + int32_t tokenId = 3333; + + // Insert a real AudioWorkgroup into map + std::shared_ptr workgroupPtr = std::make_shared(groupId); + service->audioWorkgroupMap_[pid].groups[groupId] = workgroupPtr; + + int32_t ret = service->RemoveThreadFromGroup(pid, groupId, tokenId); + + EXPECT_TRUE(ret == 0); +} + /** * @tc.name : Test AddThreadToGroup * @tc.type : FUNC @@ -599,6 +669,30 @@ HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_005, TestSize.Level0) EXPECT_NE(ret, SUCCESS); } +/** + * @tc.name : Test AddThreadToGroup + * @tc.type : FUNC + * @tc.number: AddThreadToGroup_006 + * @tc.desc : Test when the number of threads per process reaches AUDIO_MAX_RT_THREADS, + * AddThreadToGroup should return ERR_NOT_SUPPORTED. + */ +HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_006, TestSize.Level1) +{ + AudioResourceService* service = AudioResourceService::GetInstance(); + int32_t pid = 12345; + int32_t groupId = 67890; + int32_t tokenId = 12346; + + std::shared_ptr workgroupPtr = std::make_shared(groupId); + service->audioWorkgroupMap_[pid].groups[groupId] = workgroupPtr; + + for (int i = 0; i < 4; ++i) { + workgroupPtr->AddThread(tokenId + i + 100); + } + int32_t ret = service->AddThreadToGroup(pid, groupId, tokenId); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); +} + /** * @tc.name : Test ReleaseAudioWorkgroup * @tc.type : FUNC @@ -655,6 +749,27 @@ HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_005, TestSize.Level0) EXPECT_NE(ret, SUCCESS); } +/** + * @tc.name : ReleaseAudioWorkgroup + * @tc.type : FUNC + * @tc.number: ReleaseAudioWorkgroup_006 + * @tc.desc : Test successful release of an existing audio workgroup. Covers the normal branch where reply.paramA == 0. + */ +HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_006, TestSize.Level1) +{ + AudioResourceService* service = AudioResourceService::GetInstance(); + int32_t pid = 12345; + int32_t groupId = 67890; + + std::shared_ptr workgroupPtr = std::make_shared(groupId); + service->audioWorkgroupMap_[pid].groups[groupId] = workgroupPtr; + + int32_t ret = service->ReleaseAudioWorkgroup(pid, groupId); + + EXPECT_EQ(ret, SUCCESS); + EXPECT_EQ(service->audioWorkgroupMap_.count(pid), 0); +} + /** * @tc.name : Test AudioWorkgroupCheck * @tc.type : FUNC @@ -682,5 +797,113 @@ HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_004, TestSize.Level0) EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid), SUCCESS); } +/** + * @tc.name : Test WorkgroupRendererMonitor + * @tc.type : FUNC + * @tc.number: WorkgroupRendererMonitor + * @tc.desc : Test WorkgroupRendererMonitor when find workgroup + */ +HWTEST(AudioResourceServiceUnitTest, WorkgroupRendererMonitor_002, TestSize.Level0) +{ + int32_t testPid = 321; + audioResourceService.audioWorkgroupMap_[testPid].permission = false; + audioResourceService.WorkgroupRendererMonitor(testPid, true); + + EXPECT_TRUE(audioResourceService.audioWorkgroupMap_[testPid].permission); +} + +/** + * @tc.name : Test deathRecipient + * @tc.type : FUNC + * @tc.number: OnWorkgroupRemoteDied_001 + * @tc.desc : Test OnWorkgroupRemoteDied when called + */ +HWTEST(AudioResourceServiceUnitTest, OnWorkgroupRemoteDied_001, TestSize.Level0) +{ + std::shared_ptr workgroup = std::make_shared(testRtgId); + std::shared_ptr workGroup = std::make_shared(testRtgId); + sptr remoteObj = nullptr; + + audioResourceService.audioWorkgroupMap_[10].groups[testRtgId] = {workGroup}; + audioResourceService.OnWorkgroupRemoteDied(workgroup, remoteObj); + EXPECT_EQ(audioResourceService.audioWorkgroupMap_[10].groups.count(testRtgId), 1); +} + +/** + * @tc.name : Test AudioWorkgroupCheck + * @tc.type : FUNC + * @tc.number: AudioWorkgroupCheck + * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup + */ +HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_008, TestSize.Level0) +{ + int32_t pid = 4321; + for (int i = 0; i <= AUDIO_MAX_GRP_PER_PROCESS; i++) { + audioResourceService.audioWorkgroupMap_[pid].groups[i] = nullptr; + } + EXPECT_TRUE(audioResourceService.IsProcessInWorkgroup(pid)); + EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid), ERR_NOT_SUPPORTED); + + pid = 532; + audioResourceService.audioWorkgroupMap_[pid].groups[pid] = nullptr; + audioResourceService.audioWorkgroupMap_[pid].hasSystemPermission = false; + + for (int i = 0; i <= AUDIO_MAX_PROCESS; i++) { + audioResourceService.audioWorkgroupMap_[i].groups[i] = nullptr; + } + EXPECT_FALSE(audioResourceService.IsProcessInWorkgroup(pid + 1)); + EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid + 1), ERR_NOT_SUPPORTED); +} + +/** + * @tc.name : AudioWorkgroupCheck + * @tc.type : FUNC + * @tc.number: AudioWorkgroupCheck_005 + * @tc.desc : Should return ERR_NOT_SUPPORTED if a process already has >= AUDIO_MAX_GRP_PER_PROCESS groups. + */ +HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_005, TestSize.Level1) +{ + auto* service = AudioResourceService::GetInstance(); + int32_t pid = 1001; + service->audioWorkgroupMap_.clear(); + service->audioWorkgroupMap_[pid].groups.clear(); + for (int i = 0; i < 4; ++i) { + service->audioWorkgroupMap_[pid].groups[i] = std::make_shared(i); + } + EXPECT_EQ(service->AudioWorkgroupCheck(pid), ERR_NOT_SUPPORTED); +} + +/** + * @tc.name : AudioWorkgroupCheck + * @tc.type : FUNC + * @tc.number: AudioWorkgroupCheck_006 + * @tc.desc : Should enter the for-loop over processes when not in any group. + */ +HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_006, TestSize.Level1) +{ + auto* service = AudioResourceService::GetInstance(); + service->audioWorkgroupMap_.clear(); + // Fill a few process entries, all without system permission + service->audioWorkgroupMap_[2001].hasSystemPermission = false; + int32_t pid = 9999; + EXPECT_EQ(service->AudioWorkgroupCheck(pid), SUCCESS); +} + +/** + * @tc.name : AudioWorkgroupCheck - Max Process Limit + * @tc.type : FUNC + * @tc.number: AudioWorkgroupCheck_007 + * @tc.desc : Should return ERR_NOT_SUPPORTED if normal process count reaches AUDIO_MAX_PROCESS. + */ +HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_007, TestSize.Level1) +{ + auto* service = AudioResourceService::GetInstance(); + service->audioWorkgroupMap_.clear(); + for (int i = 0; i < 2; ++i) { + service->audioWorkgroupMap_[3000 + i].hasSystemPermission = false; + } + int32_t pid = 8888; + EXPECT_EQ(service->AudioWorkgroupCheck(pid), ERR_NOT_SUPPORTED); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_service/test/unittest/audio_ring_cache_unit_test.cpp b/services/audio_service/test/unittest/audio_ring_cache_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..66f2bbbc5f50f949e5a2a8765432dfce7f68b0b4 --- /dev/null +++ b/services/audio_service/test/unittest/audio_ring_cache_unit_test.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "gtest/gtest.h" +#include "audio_ring_cache.h" +#include "audio_service_log.h" + +#include "securec.h" + +using namespace std; +using namespace testing::ext; +using namespace testing; +namespace OHOS { +namespace AudioStandard { + +static const size_t MAX_CACHE_SIZE = 16 * 1024 * 1024; // 16M +static const size_t BASE_INDEX_FENCE = SIZE_MAX - 2 * MAX_CACHE_SIZE; + +class Test : public ::testing::Test { +protected: +void SetUp() override {} +void TearDown() override {} +}; + +class AudioRingCacheTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +/** + * @tc.name : Test AudioRingCacheTest API + * @tc.type : FUNC + * @tc.number: AudioRingCache_001 + * @tc.desc : Test AudioRingCacheTest interface. + */ +HWTEST(AudioRingCacheTest, AudioRingCache_001, TestSize.Level0) +{ + size_t cacheSize = 64; + std::unique_ptr audioringcache = std::make_unique(cacheSize); + + EXPECT_EQ(nullptr, audioringcache->Create(MAX_CACHE_SIZE + 1)); +} + +/** + * @tc.name : Test AudioRingCacheTest API + * @tc.type : FUNC + * @tc.number: AudioRingCache_002 + * @tc.desc : Test AudioRingCacheTest interface. + */ + +HWTEST(AudioRingCacheTest, AudioRingCache_002, TestSize.Level0) +{ + size_t cacheSize = 64; + std::unique_ptr audioringcache = std::make_unique(cacheSize); + + audioringcache->writeIndex_ = 4; + audioringcache->readIndex_ = 8; + audioringcache->cacheTotalSize_ = 0; + BufferWrap buffer; + OptResult result = audioringcache->Enqueue(buffer); + EXPECT_EQ(INVALID_PARAMS, result.ret); + + audioringcache->baseIndex_ = 2; + audioringcache->writeIndex_ = 12; + audioringcache->cacheTotalSize_ = 8; + result = audioringcache->Enqueue(buffer); + EXPECT_EQ(0, result.size); + + audioringcache->baseIndex_ = 64; + result = audioringcache->Enqueue(buffer); + EXPECT_EQ(8, audioringcache->readIndex_); +} + +/** + * @tc.name : Test AudioRingCacheTest API + * @tc.type : FUNC + * @tc.number: AudioRingCache_003 + * @tc.desc : Test AudioRingCacheTest interface. + */ +HWTEST(AudioRingCacheTest, AudioRingCache_003, TestSize.Level0) +{ + size_t cacheSize = 64; + std::unique_ptr audioringcache = std::make_unique(cacheSize); + + BufferWrap buffer; + audioringcache->writeIndex_ = 4; + audioringcache->readIndex_ = 8; + audioringcache->cacheTotalSize_ = 0; + audioringcache->baseIndex_ = BASE_INDEX_FENCE; + audioringcache->GetWritableSizeNoLock(); + OptResult result = audioringcache->Dequeue(buffer); + EXPECT_EQ(0, result.size); + + audioringcache->baseIndex_ = 10; + audioringcache->GetWritableSizeNoLock(); + result = audioringcache->Dequeue(buffer); + EXPECT_EQ(INVALID_PARAMS, result.ret); + + audioringcache->baseIndex_ = 2; + audioringcache->writeIndex_ = 12; + audioringcache->cacheTotalSize_ = 8; + audioringcache->GetWritableSizeNoLock(); + result = audioringcache->Dequeue(buffer); + EXPECT_EQ(INVALID_PARAMS, result.ret); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp b/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp index 797670bd6bddd45b0102404756876ec1e1d7f498..3f1f9954c1854cdc3c33a7bb430e2cb98c2dfb25 100644 --- a/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp @@ -87,12 +87,43 @@ TEST_F(HpaeAudioServerHpaeDumpTest, HpaeAudioServerHpaeDumpTest_002) HpaeSinkSourceInfo sourceInfo = { "Built_in_mic", "" }; audioServerHpaeDump_->devicesInfo_.sourceInfos.push_back(sourceInfo); - dumpString = ""; + dumpString.clear(); audioServerHpaeDump_->RecordSourceDump(dumpString); EXPECT_EQ(dumpString.empty(), false); std::queue argQue; - dumpString = ""; + dumpString.clear(); + audioServerHpaeDump_->ArgDataDump(dumpString, argQue); + EXPECT_EQ(dumpString.empty(), false); +} + +TEST_F(HpaeAudioServerHpaeDumpTest, ArgDataDump_001) +{ + bool isTrue = audioServerHpaeDump_->GetDevicesInfo(); + EXPECT_EQ(isTrue, true); + std::string dumpString; + + std::queue argQue; + argQue.push(u"-h"); + dumpString.clear(); + audioServerHpaeDump_->ArgDataDump(dumpString, argQue); + EXPECT_EQ(dumpString.empty(), false); + + argQue.pop(); + argQue.push(u"-p"); + dumpString.clear(); + audioServerHpaeDump_->ArgDataDump(dumpString, argQue); + EXPECT_EQ(dumpString.empty(), false); + + argQue.pop(); + argQue.push(u"-f"); + dumpString.clear(); + audioServerHpaeDump_->ArgDataDump(dumpString, argQue); + EXPECT_EQ(dumpString.empty(), false); + + argQue.pop(); + argQue.push(u"-m"); + dumpString.clear(); audioServerHpaeDump_->ArgDataDump(dumpString, argQue); EXPECT_EQ(dumpString.empty(), false); } diff --git a/services/audio_service/test/unittest/audio_service_common_unit_test.cpp b/services/audio_service/test/unittest/audio_service_common_unit_test.cpp index a07c4e0d4b62f46e2788efca2e4650902acd89ef..a42ed0bc27142af26e11a1860104d58c0db21eba 100644 --- a/services/audio_service/test/unittest/audio_service_common_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_common_unit_test.cpp @@ -1781,5 +1781,90 @@ HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetDuckFactor_002, TestSize float result = ohAudioBuffer->GetDuckFactor(); EXPECT_FLOAT_EQ(result, MIN_FLOAT_VOLUME); } + +/** +* @tc.name : Test GetTimeOfPos API +* @tc.type : FUNC +* @tc.number: GetTimeOfPos_001 +* @tc.desc : Test GetTimeOfPos interface. +*/ +HWTEST(AudioServiceCommonUnitTest, GetTimeOfPos_001, TestSize.Level1) +{ + g_linearPosTimeModel = std::make_unique(); + + uint64_t posInFrame = 20; + int64_t invalidTime = -1; + g_linearPosTimeModel->stampFrame_ = 0; + g_linearPosTimeModel->sampleRate_ = 0; + int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame); + EXPECT_EQ(invalidTime, retPos); +} + +/** +* @tc.name : Test GetTimeOfPos API +* @tc.type : FUNC +* @tc.number: GetTimeOfPos_002 +* @tc.desc : Test GetTimeOfPos interface. +*/ +HWTEST(AudioServiceCommonUnitTest, GetTimeOfPos_002, TestSize.Level1) +{ + g_linearPosTimeModel = std::make_unique(); + + uint64_t posInFrame = 1; + int64_t invalidTime = -1; + g_linearPosTimeModel->stampFrame_ = 10; + g_linearPosTimeModel->sampleRate_ = 0; + int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame); + EXPECT_EQ(invalidTime, retPos); +} + +/** +* @tc.name : Test Init API +* @tc.type : FUNC +* @tc.number: Init_001 +* @tc.desc : Test Init interface. +*/ +HWTEST(AudioServiceCommonUnitTest, Init_001, TestSize.Level1) +{ + const size_t testMaxSize = 16 * 1024 * 1024 + 1; + size_t testSize = 3840; + std::unique_ptr ringCache = AudioRingCache::Create(testSize); + EXPECT_NE(nullptr, ringCache); + ringCache->cacheTotalSize_ = testMaxSize; + bool result = ringCache->Init(); + EXPECT_EQ(result, false); +} + +/** +* @tc.name : Test Init API +* @tc.type : FUNC +* @tc.number: Init_002 +* @tc.desc : Test Init interface. +*/ +HWTEST(AudioServiceCommonUnitTest, Init_002, TestSize.Level1) +{ + size_t testSize = 3840; + std::unique_ptr ringCache = AudioRingCache::Create(testSize); + EXPECT_NE(nullptr, ringCache); + ringCache->cacheTotalSize_ = -1; + bool result = ringCache->Init(); + EXPECT_EQ(result, false); +} + +/** +* @tc.name : Test Create API +* @tc.type : FUNC +* @tc.number: Create_001 +* @tc.desc : Test Create interface. +*/ +HWTEST(AudioServiceCommonUnitTest, Create_001, TestSize.Level1) +{ + size_t testSize = 3840; + size_t cacheSize = 16 * 1024 * 1024 + 1; + std::unique_ptr ringCache = AudioRingCache::Create(testSize); + EXPECT_NE(nullptr, ringCache); + std::unique_ptr result = ringCache->Create(cacheSize); + EXPECT_EQ(result, nullptr); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp b/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp index fd9e49efb05201a67c99389ff863f861bd53f8a1..63b0e4ca4fde878ec0480d45cc19beba2ac0b406 100644 --- a/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp @@ -259,5 +259,32 @@ HWTEST(AudioStreamMonitorTest, OnMuteStateChange_001, TestSize.Level1) EXPECT_EQ(test->isMuted_, isMuted); delete test; } + +/** + * @tc.name : Test GetVolumeBySessionId API + * @tc.type : FUNC + * @tc.number: GetVolumeBySessionId_001 + */ +HWTEST(AudioStreamMonitorTest, GetVolumeBySessionId_001, TestSize.Level1) +{ + DataTransferMonitorParam para; + para.clientUID = 20002000; + AudioStreamMonitor::GetInstance().RegisterAudioRendererDataTransferStateListener(para, 10000, 10000); + + AudioProcessConfig cfg; + cfg.originalSessionId = 0; + std::shared_ptr checker = std::make_shared(cfg); + AudioStreamMonitor::GetInstance().AddCheckForMonitor(cfg.originalSessionId, checker); + + float volume; + int32_t ret; + ret = AudioStreamMonitor::GetInstance().GetVolumeBySessionId(0, volume); + EXPECT_EQ(ret, SUCCESS); + ret = AudioStreamMonitor::GetInstance().GetVolumeBySessionId(1, volume); + EXPECT_EQ(ret, ERR_UNKNOWN); + AudioStreamMonitor::GetInstance().DeleteCheckForMonitor(0); + int32_t size = AudioStreamMonitor::GetInstance().audioStreamCheckers_.size(); + EXPECT_EQ(size, 0); +} } } \ No newline at end of file diff --git a/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp b/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp index b127e486f2fe1d2fcae23a5c22f7f7907398d549..78ad8c64670f56961cd91a028133594a3b6c1d74 100644 --- a/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp +++ b/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp @@ -409,8 +409,8 @@ HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_010, TestSize.Level1 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_011, TestSize.Level1) { AudioProcessConfig processConfig = GetInnerCapConfig(); - int32_t UID_MSDP_SA = 6699; - processConfig.callerUid = UID_MSDP_SA; + int32_t udimsdpsa = 6699; + processConfig.callerUid = udimsdpsa; std::weak_ptr streamListener; PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK); @@ -466,8 +466,8 @@ HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_012, TestSize.Level1 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_013, TestSize.Level1) { AudioProcessConfig processConfig = GetInnerCapConfig(); - int32_t UID_MSDP_SA = 6699; - processConfig.callerUid = UID_MSDP_SA; + int32_t udimsdpsa = 6699; + processConfig.callerUid = udimsdpsa; std::weak_ptr streamListener; PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK); diff --git a/services/audio_service/test/unittest/client/audio_system_manager_unit_test.cpp b/services/audio_service/test/unittest/client/audio_system_manager_unit_test.cpp index 56a453f7ee11d7c4b4762fe20997dc9472a5be5c..afa6903385fdcb39cc7b99a077e1344357fb19c6 100644 --- a/services/audio_service/test/unittest/client/audio_system_manager_unit_test.cpp +++ b/services/audio_service/test/unittest/client/audio_system_manager_unit_test.cpp @@ -1750,5 +1750,91 @@ HWTEST(AudioSystemManagerUnitTest, RemoveWorkgroupChangeCallback_001, TestSize.L EXPECT_EQ(nullptr, audioWorkgroupCallbackImpl.workgroupCb_); } +/** + * @tc.name : Test SetVolumeWithDevice API + * @tc.number : SetVolumeWithDevice_002 + * @tc.desc : Test SetVolumeWithDevice interface + */ +HWTEST(AudioSystemManagerUnitTest, SetVolumeWithDevice_002, TestSize.Level4) +{ + DeviceType deviceType = DEVICE_TYPE_SPEAKER; + AudioSystemManager audioSystemManager; + int32_t volumeLevel = 5; + EXPECT_EQ(audioSystemManager.SetVolumeWithDevice(STREAM_ULTRASONIC, volumeLevel, deviceType), + ERR_PERMISSION_DENIED); +} + +/** + * @tc.name : Test SetVolumeWithDevice API + * @tc.number : SetVolumeWithDevice_003 + * @tc.desc : Test SetVolumeWithDevice interface + */ +HWTEST(AudioSystemManagerUnitTest, SetVolumeWithDevice_003, TestSize.Level4) +{ + DeviceType deviceType = DEVICE_TYPE_SPEAKER; + AudioSystemManager audioSystemManager; + int32_t volumeLevel = 5; + EXPECT_EQ(audioSystemManager.SetVolumeWithDevice(STREAM_INTERNAL_FORCE_STOP, volumeLevel, deviceType), + ERR_NOT_SUPPORTED); +} + +/** + * @tc.name : Test GetPinValueForPeripherals API + * @tc.type : FUNC + * @tc.number: GetPinValueForPeripherals_003 + * @tc.desc : Test GetPinValueForPeripherals interface. + */ +HWTEST(AudioSystemManagerUnitTest, GetPinValueForPeripherals_003, TestSize.Level4) +{ + AudioPin pinValue = AudioSystemManager::GetInstance()->GetPinValueForPeripherals(DEVICE_TYPE_WIRED_HEADPHONES, + OUTPUT_DEVICE, DM_DEVICE_TYPE_UWB); + EXPECT_EQ(pinValue, AUDIO_PIN_OUT_HEADPHONE); +} + +/** + * @tc.name : Test StartGroup API + * @tc.number : StartGroup_002 + * @tc.desc : Test StartGroup interface + */ +HWTEST(AudioSystemManagerUnitTest, StartGroup_002, TestSize.Level4) +{ + AudioSystemManager manager; + bool needUpdatePrio = true; + int32_t testWorkgroupid = 1; + int32_t startTimeMs = 500; + int32_t endTimeMs = 1000; + std::unordered_map threads = { + {101, true}, + {102, true} + }; + int32_t result = manager.StartGroup(testWorkgroupid, startTimeMs, endTimeMs, threads, needUpdatePrio); + EXPECT_EQ(result, AUDIO_ERR); +} + +/** +* @tc.name : Test ConfigDistributedRoutingRole API +* @tc.number : ConfigDistributedRoutingRoleTest_002 +* @tc.desc : Test ConfigDistributedRoutingRole interface. +*/ +HWTEST(AudioSystemManagerUnitTest, ConfigDistributedRoutingRoleTest_002, TestSize.Level4) +{ + CastType castType = CAST_TYPE_ALL; + std::shared_ptr audioDevDesc = std::make_shared();; + audioDevDesc->networkId_ = LOCAL_NETWORK_ID; + int32_t result = AudioSystemManager::GetInstance()->ConfigDistributedRoutingRole(audioDevDesc, castType); + EXPECT_EQ(result, ERR_INVALID_PARAM); +} + +/** + * @tc.name : Test GetTypeValueFromPin API + * @tc.type : FUNC + * @tc.number: GetTypeValueFromPin_003 + * @tc.desc : Test GetTypeValueFromPin interface. + */ +HWTEST(AudioSystemManagerUnitTest, GetTypeValueFromPin_003, TestSize.Level4) +{ + DeviceType deviceValue = AudioSystemManager::GetInstance()->GetTypeValueFromPin(AUDIO_PIN_IN_UWB); + EXPECT_EQ(deviceValue, DEVICE_TYPE_ACCESSORY); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp b/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp index daf988a70ce36fd3282be347f7db27060ea4d89e..2bfdd3cf01cb972089d0ec5c712decedd93f988d 100644 --- a/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp +++ b/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp @@ -1953,5 +1953,92 @@ HWTEST(CapturerInClientUnitTest, FetchDeviceForSplitStream_003, TestSize.Level2) EXPECT_NE(capturerInClientInner->CheckRestoreStatus(), NO_NEED_FOR_RESTORE); } + +/** + * @tc.name : Test OnOperationHandled API + * @tc.type : FUNC + * @tc.number: OnOperationHandled_002 + * @tc.desc : Test OnOperationHandled interface. + */ +HWTEST(CapturerInClientUnitTest, OnOperationHandled_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(STREAM_MUSIC, getpid()); + Operation operation = Operation::RESTORE_SESSION; + int64_t result = 1; + capturerInClientInner_->audioStreamTracker_ = nullptr; + int32_t ret = capturerInClientInner_->OnOperationHandled(operation, result); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test GetFrameCount API + * @tc.type : FUNC + * @tc.number: GetFrameCount_002 + * @tc.desc : Test GetFrameCount interface. + */ +HWTEST(CapturerInClientUnitTest, GetFrameCount_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner = + std::make_shared(STREAM_MUSIC, getpid()); + uint32_t frameCount = -111; + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + + int32_t result = capturerInClientInner->GetFrameCount(frameCount); + EXPECT_EQ(result, SUCCESS); +} + +/** + * @tc.name : Test Clear API + * @tc.type : FUNC + * @tc.number: Clear_002 + * @tc.desc : Test Clear interface. + */ +HWTEST(CapturerInClientUnitTest, Clear_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(STREAM_MUSIC, getpid()); + capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; + capturerInClientInner_->cbBuffer_.reset(new uint8_t[VALUE_TEN]); + int32_t ret = capturerInClientInner_->Clear(); + EXPECT_EQ(ret, ERR_INCORRECT_MODE); +} + +/** + * @tc.name : Test StopAudioStream API + * @tc.type : FUNC + * @tc.number: StopAudioStream_004 + * @tc.desc : Test StopAudioStream interface. + */ +HWTEST(CapturerInClientUnitTest, StopAudioStream_004, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner = + std::make_shared(STREAM_MUSIC, getpid()); + capturerInClientInner->state_ = State::PAUSED; + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + capturerInClientInner->ipcStream_ = std::make_shared().get(); + bool result = capturerInClientInner->StopAudioStream(); + EXPECT_EQ(capturerInClientInner->state_, State::INVALID); + EXPECT_EQ(result, false); +} + +/** + * @tc.name : Test Read API + * @tc.type : FUNC + * @tc.number: Read_002 + * @tc.desc : Test Read interface. + */ +HWTEST(CapturerInClientUnitTest, Read_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(STREAM_MUSIC, getpid()); + capturerInClientInner_->state_ = State::NEW; + size_t userSize = 16; + uint8_t buffer = 0; + bool isBlockingRead = false; + capturerInClientInner_->readLogTimes_ = VALUE_TEN; + int32_t ret = capturerInClientInner_->Read(buffer, userSize, isBlockingRead); + EXPECT_EQ(ret, ERR_ILLEGAL_STATE); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp b/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp index e5e244f861bd9cf7c53d703ee5bf5490040aed17..9548667f2b1c8be88df1da1d03a4ce9a66df6884 100644 --- a/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp +++ b/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp @@ -1754,5 +1754,63 @@ HWTEST(FastSystemStreamUnitTest, RestoreAudioStream_006, TestSize.Level1) int ret = fastAudioStream->RestoreAudioStream(needStoreState); EXPECT_TRUE(ret); } + +/** + * @tc.name : Test RestoreAudioStream API + * @tc.type : FUNC + * @tc.number: RestoreAudioStream_007 + * @tc.desc : Test RestoreAudioStream interface using unsupported parameters. + */ +HWTEST(FastSystemStreamUnitTest, RestoreAudioStream_007, TestSize.Level1) +{ + int32_t appUid = static_cast(getuid()); + std::shared_ptr fastAudioStream = + std::make_shared(STREAM_MUSIC, AUDIO_MODE_PLAYBACK, appUid); + EXPECT_EQ(fastAudioStream->RestoreAudioStream(true), false); +} + +/** + * @tc.name : Test RestoreAudioStream API + * @tc.type : FUNC + * @tc.number: RestoreAudioStream_008 + * @tc.desc : Test RestoreAudioStream interface using unsupported parameters. + */ +HWTEST(FastSystemStreamUnitTest, RestoreAudioStream_008, TestSize.Level1) +{ + int32_t appUid = static_cast(getuid()); + std::shared_ptr fastAudioStream = + std::make_shared(STREAM_MUSIC, AUDIO_MODE_PLAYBACK, appUid); + fastAudioStream->state_ = NEW; + EXPECT_NE(fastAudioStream->RestoreAudioStream(true), true); + + fastAudioStream->state_ = RUNNING; + EXPECT_EQ(fastAudioStream->RestoreAudioStream(true), false); + + fastAudioStream->state_ = PAUSED; + EXPECT_EQ(fastAudioStream->RestoreAudioStream(true), false); + + fastAudioStream->state_ = STOPPED; + EXPECT_EQ(fastAudioStream->RestoreAudioStream(true), false); + + fastAudioStream->state_ = STOPPING; + EXPECT_EQ(fastAudioStream->RestoreAudioStream(true), false); +} +/** + * @tc.name : Test GetDefaultOutputDevice API + * @tc.type : FUNC + * @tc.number: GetDefaultOutputDevice_001 + * @tc.desc : Test GetDefaultOutputDevice interface using unsupported parameters. + */ +HWTEST(FastSystemStreamUnitTest, GetDefaultOutputDevice_001, TestSize.Level1) +{ + int32_t appUid = static_cast(getuid()); + std::shared_ptr fastAudioStream = + std::make_shared(STREAM_MUSIC, AUDIO_MODE_PLAYBACK, appUid); + fastAudioStream->defaultOutputDevice_ = DeviceType::DEVICE_TYPE_SPEAKER; + + DeviceType result = fastAudioStream->GetDefaultOutputDevice(); + + EXPECT_EQ(result, DeviceType::DEVICE_TYPE_SPEAKER); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp b/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp index 5d60c467d0b4427be784146c592b22c40263d4a0..16ddb254963663a5813d769e8a52bbae9948fbe7 100644 --- a/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp +++ b/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp @@ -24,6 +24,7 @@ #include "audio_policy_manager.h" #include "capturer_in_client.h" #include "renderer_in_client.h" +#include "capturer_in_client_inner.h" using namespace testing::ext; @@ -117,5 +118,87 @@ HWTEST(IAudioStreamUnitTest, IsStreamSupported_002, TestSize.Level1) bool result = IAudioStream::IsStreamSupported(streamFlags, params); EXPECT_FALSE(result); } + +/** + * @tc.name : Test GetByteSizePerFrame API + * @tc.type : FUNC + * @tc.number: GetByteSizePerFrame_004 + * @tc.desc : Test GetByteSizePerFrame interface. + */ +HWTEST(IAudioStreamUnitTest, GetByteSizePerFrame_004, TestSize.Level1) +{ + AudioStreamParams params = {SAMPLE_RATE_48000, 100, SAMPLE_F32LE, 0}; + size_t result = 0; + int32_t ret = IAudioStream::GetByteSizePerFrame(params, result); + EXPECT_EQ(ret, ERR_INVALID_PARAM); + + params = {SAMPLE_RATE_48000, 100, SAMPLE_S32LE, 17}; + ret = IAudioStream::GetByteSizePerFrame(params, result); + EXPECT_EQ(ret, ERR_INVALID_PARAM); + + params = {SAMPLE_RATE_48000, 100, SAMPLE_S32LE, 5}; + ret = IAudioStream::GetByteSizePerFrame(params, result); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test IsStreamSupported API + * @tc.type : FUNC + * @tc.number: IsPlaybackChannelRelatedInfoValid_001 + * @tc.desc : Test IsPlaybackChannelRelatedInfoValid interface. + */ +HWTEST(IAudioStreamUnitTest, IsPlaybackChannelRelatedInfoValid_001, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(AudioStreamType::STREAM_MUSIC, 0); + std::uint8_t audioChannel = 100; + std::uint64_t channelLayout = 100; + EXPECT_FALSE(capturerInClientInner_->IsPlaybackChannelRelatedInfoValid(audioChannel, channelLayout)); + + audioChannel = 2; + channelLayout = 100; + EXPECT_FALSE(capturerInClientInner_->IsPlaybackChannelRelatedInfoValid(audioChannel, channelLayout)); +} + +/** + * @tc.name : Test IsStreamSupported API + * @tc.type : FUNC + * @tc.number: IsPlaybackChannelRelatedInfoValid_001 + * @tc.desc : Test IsPlaybackChannelRelatedInfoValid interface. + */ +HWTEST(IAudioStreamUnitTest, IsRecordChannelRelatedInfoValid_001, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(AudioStreamType::STREAM_MUSIC, 0); + std::uint8_t audioChannel = 2; + std::uint64_t channelLayout = 100; + EXPECT_FALSE(capturerInClientInner_->IsRecordChannelRelatedInfoValid(audioChannel, channelLayout)); +} + +/** + * @tc.name : Test IsStreamSupported API + * @tc.type : FUNC + * @tc.number: IsStreamSupported_003 + * @tc.desc : Test IsStreamSupported interface. + */ +HWTEST(IAudioStreamUnitTest, IsStreamSupported_003, TestSize.Level1) +{ + int32_t streamFlags = STREAM_FLAG_FAST; + std::uint8_t channels = 0; + std::uint8_t format = SAMPLE_S16LE; + AudioStreamParams params = {SAMPLE_RATE_11025, SAMPLE_S16LE, format, channels}; + bool result = IAudioStream::IsStreamSupported(streamFlags, params); + EXPECT_FALSE(result); + + channels = 2; + format = SAMPLE_S16LE; + params = {SAMPLE_RATE_48000, SAMPLE_S16LE, format, channels}; + result = IAudioStream::IsStreamSupported(streamFlags, params); + EXPECT_TRUE(result); + + + result = IAudioStream::IsStreamSupported(2, params); + EXPECT_TRUE(result); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp b/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp index 8064d9efa53bf6ca2dee96d6b08e2e713bc91724..4016741a7592e60598e9b28743d9e508ec099563 100644 --- a/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp +++ b/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp @@ -1633,5 +1633,141 @@ HWTEST_F(AudioVolumeUnitTest, SetAppRingMuted_004, TestSize.Level1) audioVolumeTest->appVolume_.clear(); audioVolumeTest->streamVolume_.clear(); } + +/** + * @tc.name : Test AudioVolume API + * @tc.type : FUNC + * @tc.number: GetVolume_006 + * @tc.desc : Test AudioVolume interface. + */ +HWTEST_F(AudioVolumeUnitTest, GetVolume_006, TestSize.Level1) +{ + uint32_t sessionId = 2; + int32_t volumeType = STREAM_VOICE_ASSISTANT; + std::string deviceClass = "speaker"; + int32_t streamType = STREAM_MUSIC; + int32_t streamUsage = STREAM_USAGE_MUSIC; + int32_t uid = 1000; + int32_t pid = 1000; + int32_t mode = 1; + bool isVKB = true; + ASSERT_TRUE(AudioVolume::GetInstance() != nullptr); + + StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB }; + AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams); + + SystemVolume systemVolume(STREAM_MUSIC, "speaker", 0.5f, 5, true); + AudioVolume::GetInstance()->SetSystemVolume(systemVolume); + + struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f}; + float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes); + EXPECT_EQ(volume, 0.0f); + + streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, true, mode, isVKB }; + AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams); + volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes); + EXPECT_EQ(volumes.volumeStream, 1.0f); + + volumeType = STREAM_SYSTEM; + volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes); + EXPECT_EQ(volumes.volumeStream, 1.0f); + + volumeType = STREAM_VOICE_CALL; + volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes); + EXPECT_EQ(volumes.volumeStream, 1.0f); + + volumeType = STREAM_VOICE_COMMUNICATION; + volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes); + EXPECT_EQ(volumes.volumeStream, 1.0f); + + volumes = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f}; + volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes); + EXPECT_EQ(volumes.volumeStream, 1.0f); +} + +/** + * @tc.name : Test AudioVolume API + * @tc.type : FUNC + * @tc.number: GetStreamVolume_002 + * @tc.desc : Test AudioVolume interface. + */ +HWTEST_F(AudioVolumeUnitTest, GetStreamVolume_002, TestSize.Level1) +{ + uint32_t sessionId = 531; + int32_t streamType = STREAM_MUSIC; + int32_t streamUsage = STREAM_USAGE_MUSIC; + int32_t uid = 1000; + int32_t pid = 1000; + int32_t mode = 1; + bool isVKB = true; + ASSERT_TRUE(AudioVolume::GetInstance() != nullptr); + + StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB }; + AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams); + bool isMuted = true; + AudioVolume::GetInstance()->SetStreamVolumeMute(sessionId, isMuted); + + float volumeStream = AudioVolume::GetInstance()->GetStreamVolume(sessionId); + EXPECT_EQ(volumeStream, 0.0f); + + volumeStream = AudioVolume::GetInstance()->GetStreamVolume(sessionId + 1); + EXPECT_EQ(volumeStream, 1.0f); +} + +/** + * @tc.name : Test GetCurVolume_002 API + * @tc.type : FUNC + * @tc.number: GetCurVolume_004 + * @tc.desc : Test GetCurVolume_002 interface + */ +HWTEST_F(AudioVolumeUnitTest, GetStopFadeoutState_004, TestSize.Level1) +{ + uint32_t streamIndex = 1; + AudioVolume::GetInstance()->SetStopFadeoutState(streamIndex, 1); + uint32_t result = AudioVolume::GetInstance()->GetStopFadeoutState(streamIndex); + EXPECT_EQ(result, 1); +} + +/** + * @tc.name : Test IsSameVolume API + * @tc.type : FUNC + * @tc.number: IsSameVolume_001 + * @tc.desc : Test IsSameVolume interface. + */ +HWTEST_F(AudioVolumeUnitTest, IsSameVolume_001, TestSize.Level4) +{ + float x = 0.0f; + float y = 0.0f; + EXPECT_TRUE(AudioVolume::GetInstance()->IsSameVolume(x, y));; +} + +/** + * @tc.name : Test AudioVolume API + * @tc.type : FUNC + * @tc.number: SetOffloadEnable_001 + * @tc.desc : Test AudioVolume interface. + */ +HWTEST_F(AudioVolumeUnitTest, SetOffloadEnable_001, TestSize.Level1) +{ + uint32_t streamIndex = 1; + int32_t offloadEnable = 1; + AudioVolume::GetInstance()->SetOffloadEnable(streamIndex, offloadEnable); + int32_t getOffloadType = AudioVolume::GetInstance()->GetOffloadEnable(streamIndex); + EXPECT_EQ(getOffloadType, offloadEnable); +} + +/** + * @tc.name : Test AudioVolume API + * @tc.type : FUNC + * @tc.number: SetOffloadEnable_002 + * @tc.desc : Test AudioVolume interface. + */ +HWTEST_F(AudioVolumeUnitTest, SetOffloadEnable_002, TestSize.Level1) +{ + uint32_t streamIndex = 1; + AudioVolume::GetInstance()->offloadEnable_.clear(); + uint32_t ret = AudioVolume::GetInstance()->GetOffloadEnable(streamIndex); + EXPECT_EQ(ret, 0); +} } // namespace OHOS::AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/common/limiter_unit_test/audio_limiter_unit_test.cpp b/services/audio_service/test/unittest/common/limiter_unit_test/audio_limiter_unit_test.cpp index 317fede926c5fe2ee6ed549bbde93539b468d5ca..942e2a172277cb49f1d4236f1132f115cde4566e 100644 --- a/services/audio_service/test/unittest/common/limiter_unit_test/audio_limiter_unit_test.cpp +++ b/services/audio_service/test/unittest/common/limiter_unit_test/audio_limiter_unit_test.cpp @@ -163,5 +163,34 @@ HWTEST_F(AudioLimiterUnitTest, GetLatency_001, TestSize.Level1) EXPECT_EQ(ret, BUFFER_SIZE_20MS_2CH_48000HZ_FLOAT * AUDIO_MS_PER_S / (SAMPLE_F32LE * SAMPLE_RATE_48000 * STEREO * PROC_COUNT)); } + +/** + * @tc.name : Test Process API + * @tc.type : FUNC + * @tc.number: Process_004 + * @tc.desc : Test Process interface when framelen is vaild. + */ +HWTEST_F(AudioLimiterUnitTest, Process_004, TestSize.Level1) +{ + EXPECT_NE(limiter, nullptr); + + int32_t ret = limiter->SetConfig(BUFFER_SIZE_20MS_2CH_44100HZ_16_BIT, SAMPLE_S16LE + 1, SAMPLE_RATE_44100, STEREO); + EXPECT_EQ(ret, SUCCESS); + int32_t frameLen = BUFFER_SIZE_20MS_2CH_44100HZ_16_BIT / (SAMPLE_S16LE + 1); + std::vector inBufferVector(frameLen, 0); + std::vector outBufferVector(frameLen, 0); + float *inBuffer = inBufferVector.data(); + float *outBuffer = outBufferVector.data(); + + limiter->dumpFileInput_ = fopen("text", "w+"); + ret = limiter->Process(frameLen, inBuffer, outBuffer); + EXPECT_EQ(ret, SUCCESS); + fclose(limiter->dumpFileInput_); + + limiter->dumpFileOutput_ = fopen("text", "w+"); + ret = limiter->Process(frameLen, inBuffer, outBuffer); + EXPECT_EQ(ret, SUCCESS); + fclose(limiter->dumpFileOutput_); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/ipc_stream_in_server_unit_test.cpp b/services/audio_service/test/unittest/ipc_stream_in_server_unit_test.cpp index 4c2c92c10937cbd3bbf2eaa8a0eaf2d8761485c1..e66df8d363b7f6d4db3477435cd08cedc90f8079 100644 --- a/services/audio_service/test/unittest/ipc_stream_in_server_unit_test.cpp +++ b/services/audio_service/test/unittest/ipc_stream_in_server_unit_test.cpp @@ -2164,5 +2164,224 @@ HWTEST(IpcStreamInServerUnitTest, UnsetOffloadMode_001, TestSize.Level3) auto ret = ipcStreamInServerRet.UnsetOffloadMode(); EXPECT_EQ(ret, ERR_OPERATION_FAILED); } + +/** + * @tc.name : Test Drain API + * @tc.type : FUNC + * @tc.number: Drain_001 + * @tc.desc : Test Drain interface. + */ +HWTEST(IpcStreamInServerUnitTest, Drain_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_PLAYBACK; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + + bool stopFlag = true; + ipcStreamInServerRet.rendererInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + auto result = ipcStreamInServerRet.Drain(stopFlag); + EXPECT_EQ(result, ERR_ILLEGAL_STATE); +} + +/** + * @tc.name : Test UpdatePlaybackCaptureConfig API + * @tc.type : FUNC + * @tc.number: UpdatePlaybackCaptureConfig_001 + * @tc.desc : Test UpdatePlaybackCaptureConfig interface. + */ +HWTEST(IpcStreamInServerUnitTest, UpdatePlaybackCaptureConfig_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + AudioPlaybackCaptureConfig config; + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + auto ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config); + EXPECT_EQ(ret, ERR_INVALID_OPERATION); +} + +/** + * @tc.name : Test GetSpeedPosition API + * @tc.type : FUNC + * @tc.number: GetSpeedPosition_001 + * @tc.desc : Test GetSpeedPosition interface. + */ +HWTEST(IpcStreamInServerUnitTest, GetSpeedPosition_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + + uint64_t framePos = 0; + uint64_t timestamp = 0; + uint64_t latency = 0; + int32_t base = 0; + + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + auto ret = ipcStreamInServerRet.GetSpeedPosition(framePos, timestamp, latency, base); + EXPECT_EQ(ret, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test GetOffloadApproximatelyCacheTime API + * @tc.type : FUNC + * @tc.number: GetOffloadApproximatelyCacheTime_001 + * @tc.desc : Test GetOffloadApproximatelyCacheTime interface. + */ +HWTEST(IpcStreamInServerUnitTest, GetOffloadApproximatelyCacheTime_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + uint64_t timestampRet = EFFECT_NONE; + uint64_t paWriteIndexRet = EFFECT_NONE; + uint64_t cacheTimeDspRet = EFFECT_NONE; + uint64_t cacheTimePaRet = EFFECT_NONE; + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + auto ret1 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet, + cacheTimeDspRet, cacheTimePaRet); + EXPECT_EQ(ret1, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test UpdateSpatializationState API + * @tc.type : FUNC + * @tc.number: UpdateSpatializationState_001 + * @tc.desc : Test UpdateSpatializationState interface. + */ +HWTEST(IpcStreamInServerUnitTest, UpdateSpatializationState_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + bool spatializationEnabledRet = false; + bool headTrackingEnabledRet = false; + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + auto ret = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet); + EXPECT_EQ(ret, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test SetSourceDuration API + * @tc.type : FUNC + * @tc.number: SetSourceDuration_001 + * @tc.desc : Test SetDefaultOutputDevice interface. + */ +HWTEST(IpcStreamInServerUnitTest, SetSourceDuration_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + ipcStreamInServerRet.rendererInServer_ = nullptr; + int64_t duration = 0; + auto result = ipcStreamInServerRet.SetSourceDuration(duration); + EXPECT_EQ(result, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test SetOffloadDataCallbackState API + * @tc.type : FUNC + * @tc.number: SetOffloadDataCallbackState_001 + * @tc.desc : Test SetOffloadDataCallbackState interface. + */ +HWTEST(IpcStreamInServerUnitTest, SetOffloadDataCallbackState_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + int64_t state = 0; + auto result = ipcStreamInServerRet.SetOffloadDataCallbackState(state); + EXPECT_EQ(result, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test SetOffloadDataCallbackState API + * @tc.type : FUNC + * @tc.number: SetOffloadDataCallbackState_001 + * @tc.desc : Test SetOffloadDataCallbackState interface. + */ +HWTEST(IpcStreamInServerUnitTest, SetOffloadDataCallbackState_002, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_PLAYBACK; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + ipcStreamInServerRet.rendererInServer_ = nullptr; + + int64_t state = 0; + auto result = ipcStreamInServerRet.SetOffloadDataCallbackState(state); + EXPECT_EQ(result, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test GetRate API + * @tc.type : FUNC + * @tc.number: GetRate_001 + * @tc.desc : Test GetRate interface. + */ +HWTEST(IpcStreamInServerUnitTest, GetRate_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_RECORD; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + int32_t rateRet = 0; + + auto ret = ipcStreamInServerRet.GetRate(rateRet); + EXPECT_EQ(ret, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test SetAudioHapticsSyncId API + * @tc.type : FUNC + * @tc.number: SetAudioHapticsSyncId_001 + * @tc.desc : Test SetAudioHapticsSyncId interface. + */ +HWTEST(IpcStreamInServerUnitTest, SetAudioHapticsSyncId_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_PLAYBACK; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + int32_t syncId = 0; + + ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD; + ipcStreamInServerRet.capturerInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + int32_t result = ipcStreamInServerRet.SetAudioHapticsSyncId(syncId); + EXPECT_EQ(result, ERR_OPERATION_FAILED); +} + +/** + * @tc.name : Test RegisterThreadPriority API + * @tc.type : FUNC + * @tc.number: RegisterThreadPriority_001 + * @tc.desc : Test RegisterThreadPriority interface. + */ +HWTEST(IpcStreamInServerUnitTest, RegisterThreadPriority_001, TestSize.Level4) +{ + AudioProcessConfig configRet; + AudioMode modeRet = AUDIO_MODE_PLAYBACK; + IpcStreamInServer ipcStreamInServerRet(configRet, modeRet); + pid_t tidRet = 0; + std::string clientBundleNameRet; + ipcStreamInServerRet.rendererInServer_ = std::make_shared(ipcStreamInServerRet.config_, + ipcStreamInServerRet.streamListenerHolder_); + + auto ret = ipcStreamInServerRet.RegisterThreadPriority(tidRet, clientBundleNameRet, METHOD_START); + EXPECT_EQ(ret, SUCCESS); +} } } diff --git a/services/audio_service/test/unittest/renderer_in_server_unit_test/BUILD.gn b/services/audio_service/test/unittest/renderer_in_server_unit_test/BUILD.gn index b6f80824d68100cabb73107734480f8a7956dbd8..61890a5ba5920bf479ce35a11c5a529d6b70d3ef 100644 --- a/services/audio_service/test/unittest/renderer_in_server_unit_test/BUILD.gn +++ b/services/audio_service/test/unittest/renderer_in_server_unit_test/BUILD.gn @@ -186,7 +186,7 @@ ohos_unittest("renderer_in_server_third_unit_test") { cflags = [ "-fno-access-control" ] - sources = [ "./src/renderer_in_server_second_unit_test.cpp" ] + sources = [ "./src/renderer_in_server_third_unit_test.cpp" ] include_dirs = [ "../../../server/include", diff --git a/services/audio_service/test/unittest/renderer_in_server_unit_test/src/renderer_in_server_third_unit_test.cpp b/services/audio_service/test/unittest/renderer_in_server_unit_test/src/renderer_in_server_third_unit_test.cpp index df2ebbb52d17dc93cd4f5f6fb6b30a584027e7f4..0994f6396c0209c66c542d118e7e35f17efe438f 100644 --- a/services/audio_service/test/unittest/renderer_in_server_unit_test/src/renderer_in_server_third_unit_test.cpp +++ b/services/audio_service/test/unittest/renderer_in_server_unit_test/src/renderer_in_server_third_unit_test.cpp @@ -24,6 +24,7 @@ const uint64_t TEST_LATENCY = 123456; const uint64_t TEST_FRAMEPOS = 123456; const uint64_t TEST_TIMESTAMP = 111111; const float IN_VOLUME_RANGE = 0.5f; +const uint32_t TEST_BUFLENGTH = 10; static std::shared_ptr stateListener; static std::shared_ptr streamListenerHolder = std::make_shared(); @@ -177,15 +178,17 @@ HWTEST_F(RendererInServerThirdUnitTest, RendererInServerOnStatusUpdate_005, Test * @tc.name : Test WriteMuteDataSysEvent API * @tc.type : FUNC * @tc.number: RendererInServerWriteMuteDataSysEvent_001 - * @tc.desc : Test WriteMuteDataSysEvent when buffer[0] is 0 and isInSilentState_ is true. + * @tc.desc : Test WriteMuteDataSysEvent when isInSilentState_ is true. */ HWTEST_F(RendererInServerThirdUnitTest, RendererInServerWriteMuteDataSysEvent_001, TestSize.Level1) { EXPECT_NE(nullptr, rendererInServer); rendererInServer->isInSilentState_ = 1; - uint8_t bufferTest = 0; - bufferDesc.buffer = &bufferTest; + uint8_t buffer[TEST_BUFLENGTH] = {0}; + size_t bufferSize = TEST_BUFLENGTH; + bufferDesc.buffer = buffer; + bufferDesc.bufLength = bufferSize; rendererInServer->WriteMuteDataSysEvent(bufferDesc); EXPECT_EQ(false, rendererInServer->isInSilentState_); } diff --git a/services/audio_service/test/unittest/volume_tools_unit_test.cpp b/services/audio_service/test/unittest/volume_tools_unit_test.cpp index 202a6f685fe969c2d1bb73f5bd663d25b1ad34c2..ee317c41533c8290bd10dd88e50491e3fc0056df 100644 --- a/services/audio_service/test/unittest/volume_tools_unit_test.cpp +++ b/services/audio_service/test/unittest/volume_tools_unit_test.cpp @@ -277,8 +277,8 @@ HWTEST_F(VolumeToolsUnitTest, VolumeTools_014, TestSize.Level1) { EXPECT_EQ(VolumeTools::IsZeroVolume(1e-10f), true); EXPECT_EQ(VolumeTools::IsZeroVolume(-1e-10f), true); - EXPECT_EQ(VolumeTools::IsZeroVolume(0.5f), true); - EXPECT_EQ(VolumeTools::IsZeroVolume(-0.5f), true); + EXPECT_EQ(VolumeTools::IsZeroVolume(0.5f), false); + EXPECT_EQ(VolumeTools::IsZeroVolume(-0.5f), false); } } } diff --git a/test/BUILD.gn b/test/BUILD.gn index 785496d44c7b8f400ef32e474f55031cbf1d7bf1..c2f59bb34041c8c5bd41172adf70f6827c6a8613 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -118,6 +118,7 @@ group("audio_unit_test") { "../services/audio_service/test/unittest:ipc_stream_in_server_unit_test", "../services/audio_service/test/unittest:offline_stream_in_server_unit_test", "../services/audio_service/test/unittest/hpae_adapter_manager_unit_test:hpae_adapter_manager_unit_test", + "../services/audio_service/test/unittest:audio_ring_cache_unit_test", "../services/audio_service/test/unittest:policy_handler_unit_test", "../services/audio_service/test/unittest:resource_manager_adapter_unit_test", @@ -200,7 +201,9 @@ group("audio_fuzz_test") { "fuzztest/audioadaptermanager_fuzzer:fuzztest", "fuzztest/audioadaptorbluetooth_fuzzer:fuzztest", "fuzztest/audioaffinitymanager_fuzzer:fuzztest", + "fuzztest/audiobackgroundmanager_fuzzer:fuzztest", "fuzztest/audiobufferbase_fuzzer:fuzztest", + "fuzztest/audioclienttrackercallbacklistener_fuzzer:fuzztest", "fuzztest/audiocollaborativeservice_fuzzer:fuzztest", "fuzztest/audioconnecteddevice_fuzzer:fuzztest", "fuzztest/audiocoreservice_fuzzer:fuzztest", @@ -228,6 +231,7 @@ group("audio_fuzz_test") { "fuzztest/audiomanagerstub_fuzzer:fuzztest", "fuzztest/audioperformancemonitor_fuzzer:fuzztest", "fuzztest/audiomicrophonedescriptor_fuzzer:fuzztest", + "fuzztest/audiooffloadstream_fuzzer:fuzztest", "fuzztest/audiopipeinfo_fuzzer:fuzztest", "fuzztest/audiopipemanager_fuzzer:fuzztest", "fuzztest/audiopipeselector_fuzzer:fuzztest", @@ -236,6 +240,7 @@ group("audio_fuzz_test") { # "fuzztest/audiopolicyanother_fuzzer:fuzztest", # "fuzztest/audiopolicyclient_fuzzer:fuzztest", "fuzztest/audiopolicymanager_fuzzer:fuzztest", + "fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer:fuzztest", # "fuzztest/audiopolicymore_fuzzer:fuzztest", @@ -248,8 +253,11 @@ group("audio_fuzz_test") { "fuzztest/audiopolicystatemonitor_fuzzer:fuzztest", "fuzztest/audiopolicystub_fuzzer:fuzztest", "fuzztest/audiopowerstatelistener_fuzzer:fuzztest", + "fuzztest/audioproresamplerprocess_fuzzer:fuzztest", + "fuzztest/audioproresampler_fuzzer:fuzztest", "fuzztest/audioqosmanager_fuzzer:fuzztest", "fuzztest/audiorecoverydevice_fuzzer:fuzztest", + "fuzztest/audioresourceservice_fuzzer:fuzztest", "fuzztest/audioschedule_fuzzer:fuzztest", "fuzztest/audioserver_fuzzer:fuzztest", "fuzztest/audioserverbalance_fuzzer:fuzztest", @@ -277,10 +285,14 @@ group("audio_fuzz_test") { "fuzztest/audiozone_fuzzer:fuzztest", "fuzztest/audiozoneservice_fuzzer:fuzztest", "fuzztest/audiozoneclientmanager_fuzzer:fuzztest", + "fuzztest/bluetoothdevicemanager_fuzzer:fuzztest", + "fuzztest/bluetoothscomanager_fuzzer:fuzztest", "fuzztest/captureclockmanager_fuzzer:fuzztest", + "fuzztest/capturerinserver_fuzzer:fuzztest", "fuzztest/capturermanager_fuzzer:fuzztest", "fuzztest/channelconverter_fuzzer:fuzztest", "fuzztest/coreserviceproviderstub_fuzzer:fuzztest", + "fuzztest/deviceinitcallback_fuzzer:fuzztest", "fuzztest/devicestatuslistener_fuzzer:fuzztest", "fuzztest/dfxmsgmanager_fuzzer:fuzztest", "fuzztest/dfxutils_fuzzer:fuzztest", @@ -323,8 +335,10 @@ group("audio_fuzz_test") { "fuzztest/istandardaudiozoneclient_fuzzer:fuzztest", "fuzztest/istandardspatializationstatechangelistener_fuzzer:fuzztest", "fuzztest/microphonedescriptor_fuzzer:fuzztest", + "fuzztest/offlineaudioeffectserverchain_fuzzer:fuzztest", "fuzztest/powerstatelistener_fuzzer:fuzztest", "fuzztest/resourcemanageradapter_fuzzer:fuzztest", + "fuzztest/simdutils_fuzzer:fuzztest", "fuzztest/sleaudiodevicemanager_fuzzer:fuzztest", "fuzztest/volumedatamaintainer_fuzzer:fuzztest", "fuzztest/rendererinserver_fuzzer:fuzztest", diff --git a/test/fuzztest/audioa2dpdevice_fuzzer/audio_a2dp_device_fuzzer.cpp b/test/fuzztest/audioa2dpdevice_fuzzer/audio_a2dp_device_fuzzer.cpp index 104e6707b7d56cc3928896b553c42dbee935ad16..0be593a7cce3bbc6dbb0c97928735a123cfa7a8a 100644 --- a/test/fuzztest/audioa2dpdevice_fuzzer/audio_a2dp_device_fuzzer.cpp +++ b/test/fuzztest/audioa2dpdevice_fuzzer/audio_a2dp_device_fuzzer.cpp @@ -49,7 +49,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 8; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -228,7 +227,7 @@ void SetA2dpDeviceVolumeLevelFuzzTest() AudioA2dpDevice::GetInstance().DelA2dpDevice(device); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { GetA2dpDeviceInfoFuzzTest, GetA2dpInDeviceInfoFuzzTest, GetA2dpDeviceVolumeLevelFuzzTest, diff --git a/test/fuzztest/audioa2dpoffloadmanager_fuzzer/audio_a2dp_offload_manager_fuzzer.cpp b/test/fuzztest/audioa2dpoffloadmanager_fuzzer/audio_a2dp_offload_manager_fuzzer.cpp index dfbf6460a3892700bb7945007a462e09a9283159..8faebb48b518049a36022556832d8a8d4a9af0d8 100644 --- a/test/fuzztest/audioa2dpoffloadmanager_fuzzer/audio_a2dp_offload_manager_fuzzer.cpp +++ b/test/fuzztest/audioa2dpoffloadmanager_fuzzer/audio_a2dp_offload_manager_fuzzer.cpp @@ -42,8 +42,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 12; -static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -130,49 +128,6 @@ void OffloadStopPlayingFuzzTest() manager->OffloadStopPlaying(sessionIds); } -void UpdateA2dpOffloadFlagForAllStreamFuzzTest() -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::unordered_map sessionIDToSpatializationEnableMap = { - {1, true}, - {2, false} - }; - - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector> audioRendererChangeInfos; - auto changeInfo1 = std::make_shared(); - changeInfo1->sessionId = GetData(); - constexpr int32_t rendererStateCount = - static_cast(RendererState::RENDERER_PAUSED - RendererState::RENDERER_INVALID) + 1; - changeInfo1->rendererState = static_cast(GetData() % rendererStateCount- 1); - audioRendererChangeInfos.push_back(changeInfo1); - - auto changeInfo2 = std::make_shared(); - changeInfo2->sessionId = GetData(); - changeInfo2->rendererState = static_cast(GetData() % rendererStateCount - 1); - audioRendererChangeInfos.push_back(changeInfo2); - manager->streamCollector_.audioRendererChangeInfos_ = audioRendererChangeInfos; - manager->UpdateA2dpOffloadFlagForAllStream(sessionIDToSpatializationEnableMap, deviceType); -} - -void UpdateA2dpOffloadFlagFuzzTest() -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; - std::vector allActiveSessions; - Bluetooth::A2dpStreamInfo a2dpStreamInfo; - a2dpStreamInfo.sessionId = 1; - a2dpStreamInfo.streamType = 1; - a2dpStreamInfo.isSpatialAudio = false; - allActiveSessions.push_back(a2dpStreamInfo); - constexpr int32_t stateCount = static_cast(BluetoothOffloadState::A2DP_OFFLOAD) + 1; - BluetoothOffloadState state = static_cast(GetData() % stateCount); - manager->SetA2dpOffloadFlag(state); - manager->UpdateA2dpOffloadFlag(allActiveSessions, deviceType); -} - void HandleA2dpDeviceOutOffloadFuzzTest() { std::shared_ptr manager = std::make_shared(); @@ -184,7 +139,8 @@ void HandleA2dpDeviceOutOffloadFuzzTest() BluetoothOffloadState a2dpOffloadFlag = static_cast(GetData() % stateCount); AudioDeviceDescriptor deviceDescriptor; deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; - manager->HandleA2dpDeviceOutOffload(a2dpOffloadFlag); + std::vector allRunningSessions = {1}; + manager->HandleA2dpDeviceOutOffload(a2dpOffloadFlag, allRunningSessions); } void HandleA2dpDeviceInOffloadFuzzTest() @@ -205,7 +161,8 @@ void HandleA2dpDeviceInOffloadFuzzTest() constexpr int32_t a2dpOffloadFlagCount = static_cast(BluetoothOffloadState::A2DP_OFFLOAD) + 1; BluetoothOffloadState a2dpOffloadFlag = static_cast(GetData() % a2dpOffloadFlagCount); - manager->HandleA2dpDeviceInOffload(a2dpOffloadFlag); + std::vector allRunningSessions = {1}; + manager->HandleA2dpDeviceInOffload(a2dpOffloadFlag, allRunningSessions); } void GetA2dpOffloadCodecAndSendToDspFuzzTest() @@ -218,33 +175,6 @@ void GetA2dpOffloadCodecAndSendToDspFuzzTest() manager->GetA2dpOffloadCodecAndSendToDsp(); } -void FetchStreamForA2dpOffloadFuzzTest() -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - std::vector> rendererChangeInfos; - auto changeInfo = std::make_shared(); - constexpr int32_t streamUsageCount = static_cast(StreamUsage::STREAM_USAGE_VOICE_CALL_ASSISTANT) + 1; - StreamUsage streamUsage = static_cast(GetData() % streamUsageCount - 1); - changeInfo->rendererInfo.streamUsage = streamUsage; - changeInfo->clientUID = GetData(); - changeInfo->rendererInfo.rendererFlags = STREAM_USAGE_UNKNOWN; - rendererChangeInfos.push_back(changeInfo); - manager->streamCollector_.audioRendererChangeInfos_ = rendererChangeInfos; - bool requireReset = GetData() % NUM_2; - manager->FetchStreamForA2dpOffload(requireReset); -} - -void GetVolumeGroupTypeFuzzTest() -{ - std::shared_ptr manager = std::make_shared(); - manager->Init(); - - uint32_t deviceTypeCount = GetData() % DeviceTypeVec.size(); - DeviceType deviceType = DeviceTypeVec[deviceTypeCount]; - manager->GetVolumeGroupType(deviceType); -} - void OnA2dpPlayingStateChangedFuzzTest() { shared_ptr manager = std::make_shared(); @@ -272,32 +202,14 @@ void IsA2dpOffloadConnectingFuzzTest() manager->IsA2dpOffloadConnecting(GetData()); } -void HandleActiveDeviceFuzzTest() -{ - shared_ptr manager = std::make_shared(); - manager->Init(); - AudioDeviceDescriptor deviceDescriptor; - uint32_t deviceTypeCount = GetData() % DeviceTypeVec.size(); - deviceDescriptor.deviceType_ = DeviceTypeVec[deviceTypeCount]; - deviceTypeCount = GetData() % DeviceTypeVec.size(); - manager->audioActiveDevice_.SetCurrentOutputDevice(deviceDescriptor); - manager->audioConfigManager_.isUpdateRouteSupported_ = GetData() % NUM_2; - manager->HandleActiveDevice(deviceDescriptor); -} - -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { OffloadStartPlayingFuzzTest, OffloadStopPlayingFuzzTest, - UpdateA2dpOffloadFlagForAllStreamFuzzTest, - UpdateA2dpOffloadFlagFuzzTest, HandleA2dpDeviceOutOffloadFuzzTest, HandleA2dpDeviceInOffloadFuzzTest, GetA2dpOffloadCodecAndSendToDspFuzzTest, - FetchStreamForA2dpOffloadFuzzTest, - GetVolumeGroupTypeFuzzTest, OnA2dpPlayingStateChangedFuzzTest, IsA2dpOffloadConnectingFuzzTest, - HandleActiveDeviceFuzzTest, }; bool FuzzTest(const uint8_t* rawData, size_t size) diff --git a/test/fuzztest/audioactivedevice_fuzzer/audio_active_device_fuzzer.cpp b/test/fuzztest/audioactivedevice_fuzzer/audio_active_device_fuzzer.cpp index 8957c933aaee8c1e291e2295df3b198a9966177d..09f74ca80bac592cf8df84a7201c032d0090ec70 100644 --- a/test/fuzztest/audioactivedevice_fuzzer/audio_active_device_fuzzer.cpp +++ b/test/fuzztest/audioactivedevice_fuzzer/audio_active_device_fuzzer.cpp @@ -45,7 +45,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 20; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -231,18 +230,6 @@ void SetCallDeviceActiveFuzzTest() } } -void CheckActiveOutputDeviceSupportOffloadFuzzTest() -{ - auto audioActiveDevice = std::make_shared(); - uint32_t deviceTypeCount = GetData() % DeviceTypeVec.size(); - DeviceType deviceType = DeviceTypeVec[deviceTypeCount]; - uint32_t roleCount = GetData() % DeviceRoleVec.size(); - DeviceRole role = DeviceRoleVec[roleCount]; - AudioDeviceDescriptor audioDeviceDescriptor(deviceType, role); - audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor); - audioActiveDevice->CheckActiveOutputDeviceSupportOffload(); -} - void IsDirectSupportedDeviceFuzzTest() { auto audioActiveDevice = std::make_shared(); @@ -361,8 +348,7 @@ void AudioActiveDeviceIsDeviceInVectorFuzzTest() void AudioDeviceDescriptorSetClientInfoFuzzTest() { AudioDeviceDescriptor deviceDescriptor; - std::shared_ptr clientInfo = - std::make_shared(); + AudioDeviceDescriptor::ClientInfo clientInfo; deviceDescriptor.GetDeviceCategory(); deviceDescriptor.SetClientInfo(clientInfo); } @@ -386,7 +372,7 @@ void AudioDeviceDescriptorGetKeyFuzzTest() deviceDescriptor.GetKey(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { GetActiveA2dpDeviceStreamInfoFuzzTest, GetMaxAmplitudeFuzzTest, UpdateDeviceFuzzTest, @@ -394,7 +380,6 @@ TestFuncs g_testFuncs[TESTSIZE] = { HandleNegtiveBtFuzzTest, SetDeviceActiveFuzzTest, SetCallDeviceActiveFuzzTest, - CheckActiveOutputDeviceSupportOffloadFuzzTest, IsDirectSupportedDeviceFuzzTest, IsDeviceActiveFuzzTest, AudioActiveDeviceGetCurrentOutputDeviceCategoryFuzzTest, diff --git a/test/fuzztest/audioaffinitymanager_fuzzer/audio_affinity_manager_fuzzer.cpp b/test/fuzztest/audioaffinitymanager_fuzzer/audio_affinity_manager_fuzzer.cpp index 28f504fece0b545625ed9996251cf567c6dfa130..6ae8cf8484039f4796f376d3b47e20aa13be0d1e 100644 --- a/test/fuzztest/audioaffinitymanager_fuzzer/audio_affinity_manager_fuzzer.cpp +++ b/test/fuzztest/audioaffinitymanager_fuzzer/audio_affinity_manager_fuzzer.cpp @@ -45,7 +45,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 16; static int32_t NUM_2 = 2; static int32_t NUM_3 = 3; constexpr int32_t K_HUNDRED = 100; @@ -431,7 +430,7 @@ void AudioAffinityManagerDelSelectCapturerDeviceFuzzTest() affinityManager.DelSelectCapturerDevice(clientUID); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { ParseAffinityXmlFuzzTest, OnXmlParsingCompletedFuzzTest, GetRendererDeviceFuzzTest, diff --git a/test/fuzztest/audiobackgroundmanager_fuzzer/BUILD.gn b/test/fuzztest/audiobackgroundmanager_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0db1f12bbf2732cb577c4176f3835edf7be7608e --- /dev/null +++ b/test/fuzztest/audiobackgroundmanager_fuzzer/BUILD.gn @@ -0,0 +1,57 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../accessibility.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioBackgroundManagerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audiobackgroundmanager_fuzzer" + + include_dirs = [ + "../../../services/audio_policy/server/infra/appclient/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + configs = [ "../../../services/audio_policy:audio_policy_public_config" ] + + sources = [ "audio_background_manager_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_policy:audio_policy_service_static", + ] + + external_deps = [ + "ability_runtime:wantagent_innerkits", + "background_task_mgr:bgtaskmgr_innerkits", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "hilog:libhilog", + "ipc:ipc_single", + ] + + defines = [] +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioBackgroundManagerFuzzTest" ] +} diff --git a/test/fuzztest/audiobackgroundmanager_fuzzer/audio_background_manager_fuzzer.cpp b/test/fuzztest/audiobackgroundmanager_fuzzer/audio_background_manager_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a4965ccbe4de9988fd7c652241f7bb7078bb539b --- /dev/null +++ b/test/fuzztest/audiobackgroundmanager_fuzzer/audio_background_manager_fuzzer.cpp @@ -0,0 +1,175 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_background_manager.h" +#include "app_state_listener.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +typedef void (*TestFuncs)(); + +void AudioBackgroundManagerNotifyBackgroundTaskStateChangeFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t uid = g_fuzzUtils.GetData(); + int32_t pid = g_fuzzUtils.GetData(); + bool hasBackgroundTask = g_fuzzUtils.GetData(); + AppState appState; + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + bool isClear = g_fuzzUtils.GetData(); + if (isClear) { + audioBackgroundManagerTest.appStatesMap_.clear(); + } + audioBackgroundManagerTest.NotifyBackgroundTaskStateChange(uid, pid, hasBackgroundTask); +} + +void AudioBackgroundManagerNotifySessionStateChangeFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t uid = g_fuzzUtils.GetData(); + int32_t pid = g_fuzzUtils.GetData(); + bool hasSession = g_fuzzUtils.GetData(); + AppState appState; + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + bool isClear = g_fuzzUtils.GetData(); + if (isClear) { + audioBackgroundManagerTest.appStatesMap_.clear(); + } + audioBackgroundManagerTest.NotifySessionStateChange(uid, pid, hasSession); +} + +void AudioBackgroundManagerHandleSessionStateChangeFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t uid = g_fuzzUtils.GetData(); + int32_t pid = g_fuzzUtils.GetData(); + AppState appState; + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + bool isClear = g_fuzzUtils.GetData(); + if (isClear) { + audioBackgroundManagerTest.appStatesMap_.clear(); + } + audioBackgroundManagerTest.HandleSessionStateChange(uid, pid); +} + +void AudioBackgroundManagerNotifyFreezeStateChangeFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t pid = g_fuzzUtils.GetData(); + bool isFreeze = g_fuzzUtils.GetData(); + std::set pidList; + pidList.insert(pid); + pidList.insert(g_fuzzUtils.GetData()); + AppState appState; + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + audioBackgroundManagerTest.NotifyFreezeStateChange(pidList, isFreeze); +} + +void AudioBackgroundManagerResetAllProxyFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t pid = g_fuzzUtils.GetData(); + AppState appState; + appState.isFreeze = g_fuzzUtils.GetData(); + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + audioBackgroundManagerTest.ResetAllProxy(); +} + +void AudioBackgroundManagerHandleFreezeStateChangeFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t pid = g_fuzzUtils.GetData(); + bool isFreeze = g_fuzzUtils.GetData(); + AppState appState; + appState.hasBackTask = g_fuzzUtils.GetData(); + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + audioBackgroundManagerTest.HandleFreezeStateChange(pid, isFreeze); +} + +void AudioBackgroundManagerDeleteFromMapFuzzTest() +{ + AudioBackgroundManager &audioBackgroundManagerTest = AudioBackgroundManager::GetInstance(); + int32_t pid = g_fuzzUtils.GetData(); + AppState appState; + appState.hasBackTask = g_fuzzUtils.GetData(); + audioBackgroundManagerTest.appStatesMap_.clear(); + audioBackgroundManagerTest.appStatesMap_.insert({pid, appState}); + bool isClear = g_fuzzUtils.GetData(); + if (isClear) { + audioBackgroundManagerTest.appStatesMap_.clear(); + } + audioBackgroundManagerTest.DeleteFromMap(pid); +} + +void AppStateListenerOnAppStateChangedFuzzTest() +{ + AppStateListener appStateListener; + AppExecFwk::AppProcessData appProcessData; + appStateListener.OnAppStateChanged(appProcessData); +} + +void AppStateListenerHandleAppStateChangeFuzzTest() +{ + AppStateListener appStateListener; + int32_t pid = g_fuzzUtils.GetData(); + int32_t uid = g_fuzzUtils.GetData(); + int32_t state = g_fuzzUtils.GetData(); + appStateListener.HandleAppStateChange(pid, uid, state); +} + +void AppStateListenerHandleBackgroundAppStateChangeFuzzTest() +{ + AppStateListener appStateListener; + int32_t pid = g_fuzzUtils.GetData(); + int32_t uid = g_fuzzUtils.GetData(); + int32_t state = g_fuzzUtils.GetData(); + appStateListener.HandleBackgroundAppStateChange(pid, uid, state); +} + +vector g_testFuncs = { + AudioBackgroundManagerNotifyBackgroundTaskStateChangeFuzzTest, + AudioBackgroundManagerNotifySessionStateChangeFuzzTest, + AudioBackgroundManagerHandleSessionStateChangeFuzzTest, + AudioBackgroundManagerNotifyFreezeStateChangeFuzzTest, + AudioBackgroundManagerResetAllProxyFuzzTest, + AudioBackgroundManagerHandleFreezeStateChangeFuzzTest, + AudioBackgroundManagerDeleteFromMapFuzzTest, + AppStateListenerOnAppStateChangedFuzzTest, + AppStateListenerHandleAppStateChangeFuzzTest, + AppStateListenerHandleBackgroundAppStateChangeFuzzTest, +}; +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/av_session.gni b/test/fuzztest/audiobackgroundmanager_fuzzer/corpus/init similarity index 72% rename from av_session.gni rename to test/fuzztest/audiobackgroundmanager_fuzzer/corpus/init index 878bdb8537d8168292e7223d18fe91e6666199a4..8f37f09254457133cae0f828d0a5faee7dcbd779 100644 --- a/av_session.gni +++ b/test/fuzztest/audiobackgroundmanager_fuzzer/corpus/init @@ -1,4 +1,4 @@ -# Copyright (c) 2024 Huawei Device Co., Ltd. +# Copyright (c) 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 @@ -10,10 +10,4 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - -if (!defined(global_parts_info) || - defined(global_parts_info.multimedia_av_session)) { - avsession_part_enable = true -} else { - avsession_part_enable = false -} +FUZZ \ No newline at end of file diff --git a/test/fuzztest/audiobackgroundmanager_fuzzer/project.xml b/test/fuzztest/audiobackgroundmanager_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audiobackgroundmanager_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/BUILD.gn b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ae6793fff2a4ff4e4940b92e8d71474be9558ff4 --- /dev/null +++ b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/BUILD.gn @@ -0,0 +1,54 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../accessibility.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioClientTrackerCallbackListenerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioclienttrackercallbacklistener_fuzzer" + + include_dirs = [ + "../../../services/audio_policy/server/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + configs = [] + + sources = [ "audio_client_tracker_callback_listener_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_policy:audio_policy_service_static", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_single", + ] + + defines = [] +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioClientTrackerCallbackListenerFuzzTest" ] +} diff --git a/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/audio_client_tracker_callback_listener_fuzzer.cpp b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/audio_client_tracker_callback_listener_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..38f42fc0352f1818330dfa450e1ac42606257792 --- /dev/null +++ b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/audio_client_tracker_callback_listener_fuzzer.cpp @@ -0,0 +1,139 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_client_tracker_callback_listener.h" +#include "audio_client_tracker_callback_service.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +typedef void (*TestFuncs)(); + +void ClientTrackerCallbackListenerMuteStreamImplFuzzTest() +{ + sptr object; + sptr listener = iface_cast(object); + std::shared_ptr callback = std::make_shared(listener); + CHECK_AND_RETURN(callback != nullptr); + StreamSetStateEventInternal streamSetStateEventInternal; + callback->MuteStreamImpl(streamSetStateEventInternal); + callback->UnmuteStreamImpl(streamSetStateEventInternal); + callback->PausedStreamImpl(streamSetStateEventInternal); + callback->ResumeStreamImpl(streamSetStateEventInternal); +} + +void ClientTrackerCallbackListenerGetSingleStreamVolumeImplFuzzTest() +{ + sptr object; + sptr listener = iface_cast(object); + std::shared_ptr callback = std::make_shared(listener); + CHECK_AND_RETURN(callback != nullptr); + float volume = g_fuzzUtils.GetData(); + callback->SetLowPowerVolumeImpl(volume); + callback->GetLowPowerVolumeImpl(volume); + callback->GetSingleStreamVolumeImpl(volume); +} + +void ClientTrackerCallbackListenerSetOffloadModeImplFuzzTest() +{ + sptr object; + sptr listener = iface_cast(object); + std::shared_ptr callback = std::make_shared(listener); + CHECK_AND_RETURN(callback != nullptr); + int32_t state = g_fuzzUtils.GetData(); + bool isAppBack = g_fuzzUtils.GetData(); + callback->SetOffloadModeImpl(state, isAppBack); +} + +void AudioClientTrackerCallbackServiceUnsetClientTrackerCallbackFuzzTest() +{ + AudioClientTrackerCallbackService service; + service.UnsetClientTrackerCallback(); +} + +void AudioClientTrackerCallbackServiceMuteStreamImplFuzzTest() +{ + AudioClientTrackerCallbackService service; + StreamSetStateEventInternal streamSetStateEventInternal; + service.MuteStreamImpl(streamSetStateEventInternal); + service.UnmuteStreamImpl(streamSetStateEventInternal); +} + +void AudioClientTrackerCallbackServicePausedStreamImplFuzzTest() +{ + AudioClientTrackerCallbackService service; + StreamSetStateEventInternal streamSetStateEventInternal; + service.PausedStreamImpl(streamSetStateEventInternal); +} + +void AudioClientTrackerCallbackServiceSetLowPowerVolumeImplFuzzTest() +{ + AudioClientTrackerCallbackService service; + float volume = g_fuzzUtils.GetData(); + service.SetLowPowerVolumeImpl(volume); +} + +void AudioClientTrackerCallbackServiceResumeStreamImplFuzzTest() +{ + AudioClientTrackerCallbackService service; + StreamSetStateEventInternal streamSetStateEventInternal; + service.ResumeStreamImpl(streamSetStateEventInternal); +} + +void AudioClientTrackerCallbackServiceSetOffloadModeImplFuzzTest() +{ + AudioClientTrackerCallbackService service; + int32_t state = g_fuzzUtils.GetData(); + bool isAppBack = g_fuzzUtils.GetData(); + service.SetOffloadModeImpl(state, isAppBack); +} + +void AudioClientTrackerCallbackServiceGetSingleStreamVolumeImplFuzzTest() +{ + AudioClientTrackerCallbackService service; + float volume = g_fuzzUtils.GetData(); + service.UnsetOffloadModeImpl(); + service.GetLowPowerVolumeImpl(volume); + service.GetSingleStreamVolumeImpl(volume); +} + +vector g_testFuncs = { + ClientTrackerCallbackListenerMuteStreamImplFuzzTest, + ClientTrackerCallbackListenerGetSingleStreamVolumeImplFuzzTest, + ClientTrackerCallbackListenerSetOffloadModeImplFuzzTest, + AudioClientTrackerCallbackServiceUnsetClientTrackerCallbackFuzzTest, + AudioClientTrackerCallbackServiceMuteStreamImplFuzzTest, + AudioClientTrackerCallbackServiceSetLowPowerVolumeImplFuzzTest, + AudioClientTrackerCallbackServiceResumeStreamImplFuzzTest, + AudioClientTrackerCallbackServiceSetOffloadModeImplFuzzTest, + AudioClientTrackerCallbackServiceGetSingleStreamVolumeImplFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/corpus/init b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/project.xml b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audioclienttrackercallbacklistener_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audiocollaborativeservice_fuzzer/audio_collaborative_service_fuzzer.cpp b/test/fuzztest/audiocollaborativeservice_fuzzer/audio_collaborative_service_fuzzer.cpp index 79808c057bc9e44aca2ba307a977b79308e76f54..507e6de7076dbba116176224511bd9ab48e39f3c 100644 --- a/test/fuzztest/audiocollaborativeservice_fuzzer/audio_collaborative_service_fuzzer.cpp +++ b/test/fuzztest/audiocollaborativeservice_fuzzer/audio_collaborative_service_fuzzer.cpp @@ -53,14 +53,13 @@ void AudioCollaborativeServiceUpdateCurrentDeviceFuzzTest() bool isEnabled = g_fuzzUtils.GetData(); if (isEnabled) { audioCollaborativeService.addressToCollaborativeEnabledMap_.insert( - std::make_pair(selectedAudioDevice.macAddress_, g_fuzzUtils.GetData())); + std::make_pair(selectedAudioDevice.macAddress_, g_fuzzUtils.GetData())); } else { - audioCollaborativeService.curDeviceAddress_ = ""; audioCollaborativeService.addressToCollaborativeEnabledMap_.clear(); - audioCollaborativeService.addressToCollaborativeMemoryMap_.insert( - std::make_pair(selectedAudioDevice.macAddress_, g_fuzzUtils.GetData())); } audioCollaborativeService.UpdateCurrentDevice(selectedAudioDevice); + selectedAudioDevice.deviceType_ = g_fuzzUtils.GetData(); + audioCollaborativeService.UpdateCurrentDevice(selectedAudioDevice); } void AudioCollaborativeServiceSetCollaborativePlaybackEnabledForDeviceFuzzTest() @@ -83,7 +82,7 @@ void AudioCollaborativeServiceIsCollaborativePlaybackEnabledForDeviceFuzzTest() bool isEnabled = g_fuzzUtils.GetData(); if (isEnabled) { audioCollaborativeService.addressToCollaborativeEnabledMap_.insert( - std::make_pair(selectedAudioDevice->macAddress_, g_fuzzUtils.GetData())); + std::make_pair(selectedAudioDevice->macAddress_, g_fuzzUtils.GetData())); } else { audioCollaborativeService.addressToCollaborativeEnabledMap_.clear(); } @@ -99,7 +98,7 @@ void AudioCollaborativeServiceUpdateCollaborativeStateRealFuzzTest() bool isEnabled = g_fuzzUtils.GetData(); if (isEnabled) { audioCollaborativeService.addressToCollaborativeEnabledMap_.insert( - std::make_pair(audioCollaborativeService.curDeviceAddress_, g_fuzzUtils.GetData())); + std::make_pair(audioCollaborativeService.curDeviceAddress_, g_fuzzUtils.GetData())); } else { audioCollaborativeService.addressToCollaborativeEnabledMap_.clear(); } diff --git a/test/fuzztest/audioconnecteddevice_fuzzer/audio_connected_device_fuzzer.cpp b/test/fuzztest/audioconnecteddevice_fuzzer/audio_connected_device_fuzzer.cpp index 040bbdcd414a94804cf81208ed3fcea2fe857730..13786ed43f02f96bf9cf868c26df425ebdf9b136 100644 --- a/test/fuzztest/audioconnecteddevice_fuzzer/audio_connected_device_fuzzer.cpp +++ b/test/fuzztest/audioconnecteddevice_fuzzer/audio_connected_device_fuzzer.cpp @@ -45,7 +45,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 20; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -407,7 +406,7 @@ void AudioConnectedDeviceRegisterNameMonitorHelperFuzzTest() audioConnectedDevice->RegisterNameMonitorHelper(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { IsConnectedOutputDeviceFuzzTest, CheckExistOutputDeviceFuzzTest, CheckExistInputDeviceFuzzTest, diff --git a/test/fuzztest/audiocoreservice_fuzzer/audio_core_service_fuzzer.cpp b/test/fuzztest/audiocoreservice_fuzzer/audio_core_service_fuzzer.cpp index ae82114414297de2c4350712908f1a0dcc11131f..b1e4d3feaa26e7077d8868a37b81f3b079cbc859 100644 --- a/test/fuzztest/audiocoreservice_fuzzer/audio_core_service_fuzzer.cpp +++ b/test/fuzztest/audiocoreservice_fuzzer/audio_core_service_fuzzer.cpp @@ -43,7 +43,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 21; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -216,13 +215,13 @@ void AudioCoreServiceUnexcludeOutputDevicesFuzzTest() audioCoreService->UnexcludeOutputDevices(audioDevUsage, audioDeviceDescriptors); } -void AudioCoreServiceOnReceiveBluetoothEventFuzzTest() +void AudioCoreServiceOnReceiveUpdateDeviceNameEventFuzzTest() { auto audioCoreService = std::make_shared(); std::string macAddress = "11-22-33-44-55-66"; std::string deviceName = "deviceName"; audioCoreService->Init(); - audioCoreService->OnReceiveBluetoothEvent(macAddress, deviceName); + audioCoreService->OnReceiveUpdateDeviceNameEvent(macAddress, deviceName); } void AudioCoreServiceNotifyRemoteRenderStateFuzzTest() @@ -317,7 +316,7 @@ void LoadSplitModuleFuzzTest() audioCoreService->LoadSplitModule("splitArgs", "networkId"); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { AudioCoreServiceDeInitFuzzTest, AudioCoreServiceDumpPipeManagerFuzzTest, AudioCoreServiceCheckAndSetCurrentOutputDeviceFuzzTest, @@ -328,7 +327,7 @@ TestFuncs g_testFuncs[TESTSIZE] = { AudioCoreServiceFetchInputDeviceForTrackFuzzTest, AudioCoreServiceExcludeOutputDevicesFuzzTest, AudioCoreServiceUnexcludeOutputDevicesFuzzTest, - AudioCoreServiceOnReceiveBluetoothEventFuzzTest, + AudioCoreServiceOnReceiveUpdateDeviceNameEventFuzzTest, AudioCoreServiceNotifyRemoteRenderStateFuzzTest, AudioCoreServiceOnCapturerSessionAddedFuzzTest, AudioCoreServiceOnCapturerSessionRemovedFuzzTest, diff --git a/test/fuzztest/audiocoreserviceentry_fuzzer/audio_core_service_entry_fuzzer.cpp b/test/fuzztest/audiocoreserviceentry_fuzzer/audio_core_service_entry_fuzzer.cpp index a12f585f30ba9231e37f39174b0ed02b58b6d7fa..3a01e82397d6c494476fcaa34219126d5565d5b2 100644 --- a/test/fuzztest/audiocoreserviceentry_fuzzer/audio_core_service_entry_fuzzer.cpp +++ b/test/fuzztest/audiocoreserviceentry_fuzzer/audio_core_service_entry_fuzzer.cpp @@ -42,7 +42,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 49; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -377,14 +376,6 @@ void AudioCoreServiceEventEntrySetCallDeviceActiveFuzzTest() eventEntry->SetCallDeviceActive(deviceType, active, address, uid); } -void AudioCoreServiceEventEntryGetAvailableDevicesFuzzTest() -{ - auto audioCoreService = std::make_shared(); - auto eventEntry = std::make_shared(audioCoreService); - AudioDeviceUsage usage = MEDIA_OUTPUT_DEVICES; - eventEntry->GetAvailableDevices(usage); -} - void AudioCoreServiceEventEntryRegisterTrackerFuzzTest() { auto audioCoreService = std::make_shared(); @@ -429,13 +420,13 @@ void AudioCoreServiceEventEntryGetAudioCapturerMicrophoneDescriptorsFuzzTest() eventEntry->GetAudioCapturerMicrophoneDescriptors(sessionId); } -void AudioCoreServiceEventEntryOnReceiveBluetoothEventFuzzTest() +void AudioCoreServiceEventEntryOnReceiveUpdateDeviceNameEventFuzzTest() { auto audioCoreService = std::make_shared(); auto eventEntry = std::make_shared(audioCoreService); std::string macAddress = "11-22-33-44-55-66"; std::string deviceName = "deviceName"; - eventEntry->OnReceiveBluetoothEvent(macAddress, deviceName); + eventEntry->OnReceiveUpdateDeviceNameEvent(macAddress, deviceName); } void AudioCoreServiceEventEntrySelectOutputDeviceFuzzTest() @@ -627,7 +618,24 @@ void AudioCoreServiceEventEntryGetPreferredInputStreamTypeFuzzTest() eventEntry->GetPreferredInputStreamType(capturerInfo); } -TestFuncs g_testFuncs[TESTSIZE] = { +void AudioCoreServiceEventEntryGetMuteStateFuzzTest() +{ + auto audioCoreService = std::make_shared(); + auto eventEntry = std::make_shared(audioCoreService); + uint32_t sessionId = 0; + bool muteState = false; + eventEntry->GetVoiceMuteState(sessionId, muteState); +} + +void AudioCoreServiceEventEntryRemoveMuteStateFuzzTest() +{ + auto audioCoreService = std::make_shared(); + auto eventEntry = std::make_shared(audioCoreService); + uint32_t sessionId = 0; + eventEntry->RemoveVoiceMuteState(sessionId); +} + +TestFuncs g_testFuncs[] = { UpdateSessionOperationFuzzTest, OnServiceConnectedFuzzTest, OnServiceDisconnectedFuzzTest, @@ -653,13 +661,12 @@ TestFuncs g_testFuncs[TESTSIZE] = { AudioCoreServiceEventEntryGetPreferredInputDeviceDescriptorsFuzzTest, AudioCoreServiceEventEntryGetActiveBluetoothDeviceFuzzTest, AudioCoreServiceEventEntrySetCallDeviceActiveFuzzTest, - AudioCoreServiceEventEntryGetAvailableDevicesFuzzTest, AudioCoreServiceEventEntryRegisterTrackerFuzzTest, AudioCoreServiceEventEntryUpdateTrackerFuzzTest, AudioCoreServiceEventEntryRegisteredTrackerClientDiedFuzzTest, AudioCoreServiceEventEntryGetAvailableMicrophonesFuzzTest, AudioCoreServiceEventEntryGetAudioCapturerMicrophoneDescriptorsFuzzTest, - AudioCoreServiceEventEntryOnReceiveBluetoothEventFuzzTest, + AudioCoreServiceEventEntryOnReceiveUpdateDeviceNameEventFuzzTest, AudioCoreServiceEventEntrySelectOutputDeviceFuzzTest, AudioCoreServiceEventEntrySelectInputDeviceFuzzTest, AudioCoreServiceEventEntryGetCurrentRendererChangeInfosFuzzTest, @@ -677,6 +684,8 @@ TestFuncs g_testFuncs[TESTSIZE] = { AudioCoreServiceEventEntrySetSessionDefaultOutputDeviceFuzzTest, AudioCoreServiceEventEntryGetSessionDefaultOutputDeviceFuzzTest, AudioCoreServiceEventEntryGetPreferredInputStreamTypeFuzzTest, + AudioCoreServiceEventEntryGetMuteStateFuzzTest, + AudioCoreServiceEventEntryRemoveMuteStateFuzzTest, }; bool FuzzTest(const uint8_t* rawData, size_t size) diff --git a/test/fuzztest/audiocoreserviceprivate_fuzzer/audio_core_service_private_fuzzer.cpp b/test/fuzztest/audiocoreserviceprivate_fuzzer/audio_core_service_private_fuzzer.cpp index 724191bb190d7a24e836c07a4cb4369afcdc68f0..e989cc26d84c8f5da1846730e5cbe00556dd35de 100644 --- a/test/fuzztest/audiocoreserviceprivate_fuzzer/audio_core_service_private_fuzzer.cpp +++ b/test/fuzztest/audiocoreserviceprivate_fuzzer/audio_core_service_private_fuzzer.cpp @@ -42,7 +42,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 91; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -120,6 +119,7 @@ vector AudioFlagVec = { AUDIO_INPUT_FLAG_VOIP, AUDIO_INPUT_FLAG_VOIP_FAST, AUDIO_INPUT_FLAG_WAKEUP, + AUDIO_INPUT_FLAG_AI, AUDIO_FLAG_MAX, }; @@ -1034,28 +1034,6 @@ void AudioCoreServicePrivateHandleDeviceChangeForFetchInputDeviceFuzzTest() audioCoreService->HandleDeviceChangeForFetchInputDevice(streamDesc); } -void AudioCoreServicePrivateCheckOffloadStreamFuzzTest() -{ - static const vector testRendererStates = { - RENDERER_INVALID, - RENDERER_NEW, - RENDERER_PREPARED, - RENDERER_RUNNING, - RENDERER_STOPPED, - RENDERER_RELEASED, - RENDERER_PAUSED - }; - auto audioCoreService = std::make_shared(); - if (audioCoreService == nullptr || testRendererStates.size() == 0) { - return; - } - - AudioStreamChangeInfo streamChangeInfo; - streamChangeInfo.audioRendererChangeInfo.rendererState = - testRendererStates[GetData() % testRendererStates.size()]; - audioCoreService->CheckOffloadStream(streamChangeInfo); -} - void AudioCoreServicePrivateActivateInputDeviceFuzzTest() { auto audioCoreService = std::make_shared(); @@ -1197,22 +1175,6 @@ void AudioCoreServicePrivateReleaseOffloadPipeFuzzTest() audioCoreService->ReleaseOffloadPipe(id, paIndex, type); } -void AudioCoreServicePrivateReConfigOffloadStatusFuzzTest() -{ - auto audioCoreService = std::make_shared(); - std::shared_ptr pipeInfo = std::make_shared(); - std::shared_ptr audioStreamDescriptor = std::make_shared(); - int32_t streamActionCount = static_cast(AudioStreamAction::AUDIO_STREAM_ACTION_RECREATE) + 1; - audioStreamDescriptor->streamAction_ = static_cast(GetData() % streamActionCount); - pipeInfo->streamDescriptors_.push_back(audioStreamDescriptor); - audioCoreService->pipeManager_ = std::make_shared(); - std::shared_ptr audioDeviceDescriptor = std::make_shared(); - audioStreamDescriptor->newDeviceDescs_.push_back(audioDeviceDescriptor); - uint32_t sessionId = GetData() % NUM_2; - std::string oldSinkName = "oldSinkName"; - audioCoreService->ReConfigOffloadStatus(sessionId, pipeInfo, oldSinkName); -} - void AudioCoreServicePrivatePrepareMoveAttrsFuzzTest() { auto audioCoreService = std::make_shared(); @@ -1383,7 +1345,7 @@ void AudioCoreServicePrivateSwitchActiveHearingAidDeviceFuzzTest() audioCoreService->SwitchActiveHearingAidDevice(audioDeviceDescriptor); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { AudioCoreServicePrivateFetchRendererPipesAndExecuteFuzzTest, AudioCoreServicePrivateUpdateActiveDeviceAndVolumeBeforeMoveSessionFuzzTest, AudioCoreServicePrivateFetchCapturerPipesAndExecuteFuzzTest, @@ -1447,7 +1409,6 @@ TestFuncs g_testFuncs[TESTSIZE] = { AudioCoreServicePrivateWriteOutputRouteChangeEventFuzzTest, AudioCoreServicePrivateHandleDeviceChangeForFetchOutputDeviceFuzzTest, AudioCoreServicePrivateHandleDeviceChangeForFetchInputDeviceFuzzTest, - AudioCoreServicePrivateCheckOffloadStreamFuzzTest, AudioCoreServicePrivateActivateInputDeviceFuzzTest, LoadSplitModuleFuzzTest, AudioCoreServicePrivateGetSourceOutputsFuzzTest, @@ -1460,7 +1421,6 @@ TestFuncs g_testFuncs[TESTSIZE] = { AudioCoreServicePrivateHandleCommonSourceOpenedFuzzTest, AudioCoreServicePrivateDelayReleaseOffloadPipeFuzzTest, AudioCoreServicePrivateReleaseOffloadPipeFuzzTest, - AudioCoreServicePrivateReConfigOffloadStatusFuzzTest, AudioCoreServicePrivatePrepareMoveAttrsFuzzTest, AudioCoreServicePrivateMuteSinkPortForSwitchDeviceFuzzTest, AudioCoreServicePrivateSetVoiceCallMuteForSwitchDeviceFuzzTest, diff --git a/test/fuzztest/audiodevicecommon_fuzzer/audio_device_common_fuzzer.cpp b/test/fuzztest/audiodevicecommon_fuzzer/audio_device_common_fuzzer.cpp index 52672a506204759955be6b0c949e8c3dd9cd8350..56930586a9bf288fefcd38b6ddf50f08b7dd456b 100644 --- a/test/fuzztest/audiodevicecommon_fuzzer/audio_device_common_fuzzer.cpp +++ b/test/fuzztest/audiodevicecommon_fuzzer/audio_device_common_fuzzer.cpp @@ -50,7 +50,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 65; static int32_t NUM_2 = 2; const int32_t SESSIONID = 12345; @@ -649,54 +648,6 @@ void UpdateRouteFuzzTest() audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices); } -void ResetOffloadAndMchModeFuzzTest() -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> outputDevices; - std::shared_ptr outputDevice = std::make_shared(); - std::vector networkIdList = {"", "LocalDevice"}; - if (outputDevice == nullptr || DeviceTypeVec.size() == 0 || networkIdList.size() == 0) { - return; - } - uint32_t networkIdCount = GetData() % networkIdList.size(); - outputDevice->networkId_ = networkIdList[networkIdCount]; - uint32_t deviceTypeCount = GetData() % DeviceTypeVec.size(); - outputDevice->deviceType_ = DeviceTypeVec[deviceTypeCount]; - outputDevices.push_back(std::move(outputDevice)); - audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices); -} - -void JudgeIfLoadMchModuleFuzzTest() -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - audioDeviceCommon.JudgeIfLoadMchModule(); - AudioIOHandle moduleId = 0; - std::string moduleName = "MCH_Speaker"; - audioDeviceCommon.audioIOHandleMap_.AddIOHandleInfo(moduleName, moduleId); - audioDeviceCommon.JudgeIfLoadMchModule(); -} - -void FetchStreamForA2dpMchStreamFuzzTest() -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> descs; - std::shared_ptr desc = std::make_shared(); - descs.push_back(std::move(desc)); - audioDeviceCommon.FetchStreamForA2dpMchStream(rendererChangeInfo, descs); -} - -void FetchStreamForSpkMchStreamFuzzTest() -{ - AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); - std::shared_ptr rendererChangeInfo = std::make_shared(); - vector> descs; - std::shared_ptr desc = std::make_shared(); - descs.push_back(std::move(desc)); - audioDeviceCommon.FetchStreamForSpkMchStream(rendererChangeInfo, descs); -} - void IsRingDualToneOnPrimarySpeakerFuzzTest() { AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); @@ -835,7 +786,6 @@ void CheckAndNotifyUserSelectedDeviceFuzzTest() AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance(); std::shared_ptr desc = std::make_shared(); audioDeviceCommon.CheckAndNotifyUserSelectedDevice(desc); - audioDeviceCommon.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); } void HasLowLatencyCapabilityFuzzTest() @@ -1157,7 +1107,7 @@ void AudioDeviceCommonDeviceParamsCheckFuzzTest() audioDeviceCommon.DeviceParamsCheck(targetRole, audioDeviceDescriptors); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { FilterSourceOutputsFuzzTest, IsRingerOrAlarmerDualDevicesRangeFuzzTest, IsRingOverPlaybackFuzzTest, @@ -1187,10 +1137,6 @@ TestFuncs g_testFuncs[TESTSIZE] = { TriggerRecreateRendererStreamCallbackFuzzTest, IsDualStreamWhenRingDualFuzzTest, UpdateRouteFuzzTest, - ResetOffloadAndMchModeFuzzTest, - JudgeIfLoadMchModuleFuzzTest, - FetchStreamForA2dpMchStreamFuzzTest, - FetchStreamForSpkMchStreamFuzzTest, IsRingDualToneOnPrimarySpeakerFuzzTest, ClearRingMuteWhenCallStartFuzzTest, HandleDeviceChangeForFetchInputDeviceFuzzTest, diff --git a/test/fuzztest/audiodevicelock_fuzzer/audio_device_lock_fuzzer.cpp b/test/fuzztest/audiodevicelock_fuzzer/audio_device_lock_fuzzer.cpp index 4d230c7fcbdca493ffe23f20dd2f27e9e4b1e4d2..e9d3b92e105dd267113faab739d2ab2b1cd589c5 100644 --- a/test/fuzztest/audiodevicelock_fuzzer/audio_device_lock_fuzzer.cpp +++ b/test/fuzztest/audiodevicelock_fuzzer/audio_device_lock_fuzzer.cpp @@ -47,7 +47,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 19; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -359,7 +358,7 @@ void AudioDeviceDescriptorMarshallingToDeviceInfoFuzzTest() audioDeviceDescriptor->MarshallingToDeviceInfo(parcel, hasBTPermission, hasSystemPermission, apiVersion); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { RegisterTrackerFuzzTest, SendA2dpConnectedWhileRunningFuzzTest, HandleAudioCaptureStateFuzzTest, diff --git a/test/fuzztest/audiodevicestatus_fuzzer/audio_device_status_fuzzer.cpp b/test/fuzztest/audiodevicestatus_fuzzer/audio_device_status_fuzzer.cpp index 66ff63f9ee455a8b4a97d623b7488e6f8eb0a863..92195e5c03aa98cb52fdbdd592ab0d666ebf9555 100644 --- a/test/fuzztest/audiodevicestatus_fuzzer/audio_device_status_fuzzer.cpp +++ b/test/fuzztest/audiodevicestatus_fuzzer/audio_device_status_fuzzer.cpp @@ -49,7 +49,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 24; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -496,7 +495,7 @@ void AudioDeviceStatusOnDeviceConfigurationChangedFuzzTest() audioDeviceStatus.OnDeviceConfigurationChanged(deviceType, macAddress, deviceName, streamInfo); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { HandleArmUsbDeviceFuzzTest, RehandlePnpDeviceFuzzTest, NoNeedChangeUsbDeviceFuzzTest, diff --git a/test/fuzztest/audiodumppcm_fuzzer/audio_dump_pcm_fuzzer.cpp b/test/fuzztest/audiodumppcm_fuzzer/audio_dump_pcm_fuzzer.cpp index 79dda75ab2c55cb19b48a53ef6d0b9ba7e88ebee..9f56a9da29a40a295ee2c0aae544fd30072688b9 100644 --- a/test/fuzztest/audiodumppcm_fuzzer/audio_dump_pcm_fuzzer.cpp +++ b/test/fuzztest/audiodumppcm_fuzzer/audio_dump_pcm_fuzzer.cpp @@ -55,7 +55,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 14; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -117,7 +116,7 @@ void CacheDataFuzzTest() { std::string dumpFileName; void* srcDataPointer; - size_t dataLength; + size_t dataLength = THRESHOLD; uint8_t srcBuffer[THRESHOLD] = {0}; auto audioCacheMgrInner = std::make_shared(); if (audioCacheMgrInner == nullptr) { @@ -125,7 +124,6 @@ void CacheDataFuzzTest() } dumpFileName = "test.txt"; srcDataPointer = static_cast(srcBuffer); - dataLength = TESTSIZE; audioCacheMgrInner->isInited_ = GetData() % NUM_2; audioCacheMgrInner->CacheData(dumpFileName, srcDataPointer, dataLength); audioCacheMgrInner->isDumpingData_ = GetData() % NUM_2; @@ -244,7 +242,7 @@ void PrintCurMemoryConditionFuzzTest() audioCacheMgrInner.PrintCurMemoryCondition(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { InitFuzzTest, DeInitFuzzTest, DumpAllMemBlockFuzzTest, diff --git a/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp b/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp index 0aceda9919ae47c41ef0be8b591e9866b6b9219c..e99bcda38d5820f3955bc7ebfcee12e061e834e9 100644 --- a/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp +++ b/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp @@ -43,56 +43,31 @@ #include "audio_spatialization_service.h" #include "suspend/sync_sleep_callback_ipc_interface_code.h" #include "hibernate/sync_hibernate_callback_ipc_interface_code.h" +#include "../fuzz_utils.h" namespace OHOS { namespace AudioStandard { using namespace std; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 3; typedef void (*TestFuncs)(); -template -T GetData() -{ - T object {}; - size_t objectSize = sizeof(object); - if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) { - return object; - } - errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize); - if (ret != EOK) { - return {}; - } - g_pos += objectSize; - return object; -} - -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); -} - void GetEcSamplingRateFuzzTest() { std::vector deviceList = { USB_CLASS, DP_CLASS, }; - uint32_t deviceListCount = GetData() % deviceList.size(); + uint32_t deviceListCount = g_fuzzUtils.GetData() % deviceList.size(); string halName = deviceList[deviceListCount]; std::shared_ptr outModuleInfo = std::make_shared(); AudioEcManager& ecManager(AudioEcManager::GetInstance()); - outModuleInfo->sampleRate_ = GetData(); + outModuleInfo->sampleRate_ = g_fuzzUtils.GetData(); ecManager.GetEcSamplingRate(halName, outModuleInfo); } @@ -102,13 +77,13 @@ void GetEcChannelsFuzzTest() USB_CLASS, DP_CLASS, }; - uint32_t deviceListCount = GetData() % deviceList.size(); + uint32_t deviceListCount = g_fuzzUtils.GetData() % deviceList.size(); string halName = deviceList[deviceListCount]; std::shared_ptr outModuleInfo = std::make_shared(); AudioEcManager& ecManager(AudioEcManager::GetInstance()); outModuleInfo->channelLayout_ = CH_LAYOUT_STEREO; - std::vector insertList = {"", to_string(GetData())}; - uint32_t insertListCount = GetData() % insertList.size(); + std::vector insertList = {"", to_string(g_fuzzUtils.GetData())}; + uint32_t insertListCount = g_fuzzUtils.GetData() % insertList.size(); ecManager.dpSinkModuleInfo_.channels = insertList[insertListCount]; ecManager.GetEcChannels(halName, outModuleInfo); } @@ -119,54 +94,280 @@ void GetEcFormatFuzzTest() USB_CLASS, DP_CLASS, }; - uint32_t deviceListCount = GetData() % deviceList.size(); + uint32_t deviceListCount = g_fuzzUtils.GetData() % deviceList.size(); string halName = deviceList[deviceListCount]; std::shared_ptr outModuleInfo = std::make_shared(); AudioEcManager& ecManager(AudioEcManager::GetInstance()); outModuleInfo->format_ = SAMPLE_S32LE; - std::vector insertList = {"", to_string(GetData())}; - uint32_t insertListCount = GetData() % insertList.size(); + std::vector insertList = {"", to_string(g_fuzzUtils.GetData())}; + uint32_t insertListCount = g_fuzzUtils.GetData() % insertList.size(); ecManager.dpSinkModuleInfo_.format = insertList[insertListCount]; ecManager.GetEcFormat(halName, outModuleInfo); } -TestFuncs g_testFuncs[TESTSIZE] = { - GetEcSamplingRateFuzzTest, - GetEcChannelsFuzzTest, - GetEcFormatFuzzTest, -}; +void CloseNormalSourceFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.CloseNormalSource(); +} + +void UpdateEnhanceEffectStateFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SourceType source = g_fuzzUtils.GetData(); + ecManager.UpdateEnhanceEffectState(source); +} + +void UpdateStreamCommonInfoFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + int32_t micRefEnableState = 0; + ecManager.Init(ecEnableState, micRefEnableState); + AudioModuleInfo moduleInfo; + PipeStreamPropInfo targetInfo; + SourceType sourceType = g_fuzzUtils.GetData(); + ecManager.UpdateStreamCommonInfo(moduleInfo, targetInfo, sourceType); +} + +void GetPipeNameByDeviceForEcFuzzTest() +{ + std::vector roleList = { + "source", + "role_source", + }; + size_t index = g_fuzzUtils.GetData() % roleList.size(); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetPipeNameByDeviceForEc(roleList[index], deviceType); +} + +void GetPipeInfoByDeviceTypeForEcFuzzTest() +{ + std::vector roleList = { + "source", + "role_source", + }; + size_t index = g_fuzzUtils.GetData() % roleList.size(); + DeviceType deviceType = g_fuzzUtils.GetData(); + std::shared_ptr pipeInfo = std::make_shared(); + CHECK_AND_RETURN(pipeInfo != nullptr); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetPipeInfoByDeviceTypeForEc(roleList[index], deviceType, pipeInfo); +} -bool FuzzTest(const uint8_t* rawData, size_t size) +void GetEcTypeFuzzTest() { - if (rawData == nullptr) { - return false; - } + DeviceType inputDevice = g_fuzzUtils.GetData(); + DeviceType outputDevice = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetEcType(inputDevice, outputDevice); +} - // initialize data - RAW_DATA = rawData; - g_dataSize = size; - g_pos = 0; +void UpdateAudioEcInfoFuzzTest() +{ + AudioDeviceDescriptor inputDevice; + AudioDeviceDescriptor outputDevice; + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + int32_t micRefEnableState = 0; + ecManager.Init(ecEnableState, micRefEnableState); + ecManager.UpdateAudioEcInfo(inputDevice, outputDevice); +} - uint32_t code = GetData(); - uint32_t len = GetArrLength(g_testFuncs); - if (len > 0) { - g_testFuncs[code % len](); - } else { - AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__); - } +void ShouldOpenMicRefFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SourceType source = g_fuzzUtils.GetData(); + int32_t ecEnableState = 0; + int32_t micRefEnableState = g_fuzzUtils.GetData(); + ecManager.Init(ecEnableState, micRefEnableState); + ecManager.ShouldOpenMicRef(source); +} - return true; +void GetAudioEcInfoFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetAudioEcInfo(); + ecManager.ResetAudioEcInfo(); } + +void PresetArmIdleInputFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + ecManager.Init(ecEnableState, 0); + ecManager.PresetArmIdleInput("AA:BB:CC:DD:EE:FF"); +} + +void ActivateArmDeviceFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + ecManager.Init(ecEnableState, 0); + DeviceRole role = g_fuzzUtils.GetData(); + ecManager.ActivateArmDevice("AA:BB:CC:DD:EE:FF", role); +} + +void CloseUsbArmDeviceFuzzTest() +{ + AudioDeviceDescriptor device; + device.deviceRole_ = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.CloseUsbArmDevice(device); +} + +void UpdateArmModuleInfoFuzzTest() +{ + std::vector addressList = { + "12:34:56:78:90:AB", + "AA:BB:CC:DD:EE:FF", + "", + "invalid_address" + }; + uint32_t addressIndex = g_fuzzUtils.GetData() % addressList.size(); + std::string address = addressList[addressIndex]; + DeviceRole role = g_fuzzUtils.GetData(); + AudioModuleInfo moduleInfo; + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + int32_t micRefEnableState = 0; + ecManager.Init(ecEnableState, micRefEnableState); + ecManager.UpdateArmModuleInfo(address, role, moduleInfo); +} + +void GetTargetSourceTypeAndMatchingFlagFuzzTest() +{ + SourceType source = g_fuzzUtils.GetData(); + SourceType targetSource; + bool useMatchingPropInfo = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetTargetSourceTypeAndMatchingFlag(source, targetSource, useMatchingPropInfo); +} + +void ReloadSourceForSessionFuzzTest() +{ + SessionInfo sessionInfo; + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.ReloadSourceForSession(sessionInfo); +} + +void FetchTargetInfoForSessionAddFuzzTest() +{ + SessionInfo sessionInfo; + sessionInfo.sourceType = g_fuzzUtils.GetData(); + sessionInfo.channels = g_fuzzUtils.GetData(); + sessionInfo.rate = g_fuzzUtils.GetData(); + PipeStreamPropInfo targetInfo; + SourceType targetSourceType = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + int32_t micRefEnableState = 0; + ecManager.Init(ecEnableState, micRefEnableState); + AudioModuleInfo moduleInfo; + std::vector OpenMicSpeakerList = { + "1", + "OpenMicSpeaker" + }; + uint32_t index = g_fuzzUtils.GetData() % OpenMicSpeakerList.size(); + moduleInfo.OpenMicSpeaker = OpenMicSpeakerList[index]; + ecManager.SetPrimaryMicModuleInfo(moduleInfo); + ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); +} + +void SetDpSinkModuleInfoFuzzTest() +{ + AudioModuleInfo moduleInfo; + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.SetDpSinkModuleInfo(moduleInfo); +} + +void GetSourceOpenedFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetSourceOpened(); +} + +void GetMicRefFeatureEnableFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetMicRefFeatureEnable(); +} + +void GetHalNameForDeviceFuzzTest() +{ + std::vector roleList = { + "source", + "role_source", + }; + size_t index = g_fuzzUtils.GetData() % roleList.size(); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetHalNameForDevice(roleList[index], deviceType); +} + +void PrepareNormalSourceFuzzTest() +{ + AudioModuleInfo moduleInfo; + std::shared_ptr streamDesc = std::make_shared(); + CHECK_AND_RETURN(streamDesc != nullptr); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.PrepareNormalSource(moduleInfo, streamDesc); +} + +void GetOpenedNormalSourceSessionIdFuzzTest() +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + ecManager.GetOpenedNormalSourceSessionId(); +} + +void ReloadNormalSourceFuzzTest() +{ + SessionInfo sessionInfo; + PipeStreamPropInfo targetInfo; + SourceType targetSource = g_fuzzUtils.GetData(); + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + int32_t ecEnableState = g_fuzzUtils.GetData(); + int32_t micRefEnableState = 0; + ecManager.Init(ecEnableState, micRefEnableState); + ecManager.ReloadNormalSource(sessionInfo, targetInfo, targetSource); +} + +vector g_testFuncs = { + GetEcSamplingRateFuzzTest, + GetEcChannelsFuzzTest, + GetEcFormatFuzzTest, + CloseNormalSourceFuzzTest, + UpdateEnhanceEffectStateFuzzTest, + UpdateStreamCommonInfoFuzzTest, + GetPipeNameByDeviceForEcFuzzTest, + GetPipeInfoByDeviceTypeForEcFuzzTest, + GetEcTypeFuzzTest, + UpdateAudioEcInfoFuzzTest, + ShouldOpenMicRefFuzzTest, + GetAudioEcInfoFuzzTest, + PresetArmIdleInputFuzzTest, + ActivateArmDeviceFuzzTest, + CloseUsbArmDeviceFuzzTest, + UpdateArmModuleInfoFuzzTest, + GetTargetSourceTypeAndMatchingFlagFuzzTest, + ReloadSourceForSessionFuzzTest, + FetchTargetInfoForSessionAddFuzzTest, + SetDpSinkModuleInfoFuzzTest, + GetSourceOpenedFuzzTest, + GetMicRefFeatureEnableFuzzTest, + GetHalNameForDeviceFuzzTest, + PrepareNormalSourceFuzzTest, + GetOpenedNormalSourceSessionIdFuzzTest, + ReloadNormalSourceFuzzTest, +}; + } // namespace AudioStandard } // namesapce OHOS /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size < OHOS::AudioStandard::THRESHOLD) { - return 0; - } - - OHOS::AudioStandard::FuzzTest(data, size); + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); return 0; } diff --git a/test/fuzztest/audioeffectvolume_fuzzer/audio_effect_volume_fuzzer.cpp b/test/fuzztest/audioeffectvolume_fuzzer/audio_effect_volume_fuzzer.cpp index 338295775c39ee39f2d8f8bfa3ccec7af7507e5b..b214ee099310bc96b4415f4eae672cb21603c8d0 100644 --- a/test/fuzztest/audioeffectvolume_fuzzer/audio_effect_volume_fuzzer.cpp +++ b/test/fuzztest/audioeffectvolume_fuzzer/audio_effect_volume_fuzzer.cpp @@ -51,7 +51,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 2; typedef void (*TestFuncs)(); @@ -108,7 +107,7 @@ void StreamVolumeDeleteFuzzTest() audioEffectVolume->StreamVolumeDelete(sessionID); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { SetStreamVolumeFuzzTest, StreamVolumeDeleteFuzzTest, }; diff --git a/test/fuzztest/audiointerruptdfxcollector_fuzzer/audio_interrupt_dfx_collector_fuzzer.cpp b/test/fuzztest/audiointerruptdfxcollector_fuzzer/audio_interrupt_dfx_collector_fuzzer.cpp index cea1b9c0d732cc2636ed6b145ef82e98f60890fa..0cdb03db3db439d2d8aec6baedbc799b011e525f 100644 --- a/test/fuzztest/audiointerruptdfxcollector_fuzzer/audio_interrupt_dfx_collector_fuzzer.cpp +++ b/test/fuzztest/audiointerruptdfxcollector_fuzzer/audio_interrupt_dfx_collector_fuzzer.cpp @@ -50,7 +50,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 11; typedef void (*TestFuncs)(); @@ -176,7 +175,7 @@ void ParseSecondOfValueFuzzTest() settingProvider.ParseSecondOfValue(pos, len, input); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { FlushDfxMsgFuzzTest, WriteEffectMsgFuzzTest, GetDfxIndexesFuzzTest, diff --git a/test/fuzztest/audiointerruptgroupinfo_fuzzer/audio_interrupt_group_info_fuzzer.cpp b/test/fuzztest/audiointerruptgroupinfo_fuzzer/audio_interrupt_group_info_fuzzer.cpp index 9684929309e75f86b956a2b2574aeeefc5506115..9d461f888cb2d4fe26c010a6ceeba42cb851d4ce 100644 --- a/test/fuzztest/audiointerruptgroupinfo_fuzzer/audio_interrupt_group_info_fuzzer.cpp +++ b/test/fuzztest/audiointerruptgroupinfo_fuzzer/audio_interrupt_group_info_fuzzer.cpp @@ -50,7 +50,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 2; typedef void (*TestFuncs)(); @@ -94,7 +93,7 @@ void UnmarshallingFuzzTest() interruptGroupInfo.Unmarshalling(in); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { MarshallingFuzzTest, UnmarshallingFuzzTest, }; diff --git a/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp b/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp index 47c476547d62cddf81fe7a79af09d9f32b507d93..b61078910af713c6c0a7eeb8d7e15e260ced0c22 100644 --- a/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp +++ b/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp @@ -17,9 +17,12 @@ #include #include #undef private + +#include "../fuzz_utils.h" #include "audio_info.h" #include "audio_policy_server.h" #include "audio_interrupt_service.h" + using namespace std; namespace OHOS { @@ -27,7 +30,6 @@ namespace AudioStandard { using namespace std; const int32_t LIMITSIZE = 4; const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy"; -const uint8_t TESTSIZE = 71; const uint32_t TEST_ID_MODULO = 3; constexpr uint32_t BOOL_MODULO = 2; typedef void (*TestPtr)(const uint8_t *, size_t); @@ -1395,7 +1397,7 @@ void CanMixForActiveSessionFuzzTest(const uint8_t *rawData, size_t size) } // namespace AudioStandard } // namesapce OHOS -OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = { +OHOS::AudioStandard::TestPtr g_testPtrs[] = { OHOS::AudioStandard::InitFuzzTest, OHOS::AudioStandard::AddDumpInfoFuzzTest, OHOS::AudioStandard::SetCallbackHandlerFuzzTest, @@ -1476,8 +1478,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) if (data == nullptr || size <= 1) { return 0; } - uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE; - if (firstByte >= OHOS::AudioStandard::TESTSIZE) { + uint32_t funcSize = sizeof(g_testPtrs) / sizeof(g_testPtrs[0]); + uint8_t firstByte = *data % funcSize; + if (firstByte >= funcSize) { return 0; } data = data + 1; diff --git a/test/fuzztest/audiolimitermanager_fuzzer/audio_limiter_manager_fuzzer.cpp b/test/fuzztest/audiolimitermanager_fuzzer/audio_limiter_manager_fuzzer.cpp index 66a9dde311a82765ee043c4aa7f5791da4371ad6..749f5ae5fa9371ea261baa55ef64bd138716729c 100644 --- a/test/fuzztest/audiolimitermanager_fuzzer/audio_limiter_manager_fuzzer.cpp +++ b/test/fuzztest/audiolimitermanager_fuzzer/audio_limiter_manager_fuzzer.cpp @@ -42,7 +42,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 5; const int32_t NUM_2 = 2; const int32_t TEST_MAX_REQUEST = 7680; @@ -125,7 +124,7 @@ void CreateLimiterFuzzTest() limiterManager->CreateLimiter(sinkIndex); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { SetLimiterConfigFuzzTest, ProcessLimiterFuzzTest, ReleaseLimiterFuzzTest, diff --git a/test/fuzztest/audiomanager_fuzzer/audio_manager_fuzzer.cpp b/test/fuzztest/audiomanager_fuzzer/audio_manager_fuzzer.cpp index d0296b6b872a100c574ba99710aa0f511443256c..eb94f04b97fc8d0069ed4eef4d50aff1c74397ee 100644 --- a/test/fuzztest/audiomanager_fuzzer/audio_manager_fuzzer.cpp +++ b/test/fuzztest/audiomanager_fuzzer/audio_manager_fuzzer.cpp @@ -29,7 +29,6 @@ namespace AudioStandard { namespace { std::string g_networkId = "LocalDevice"; } -const uint8_t TESTSIZE = 4; typedef void (*TestPtr)(const uint8_t *, size_t); void AudioRendererStateCallbackFuzz::OnRendererStateChange( @@ -179,7 +178,7 @@ void AudioGroupManagerFuzzTest(const uint8_t* data, size_t size) } // namespace AudioStandard } // namesapce OHOS -OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = { +OHOS::AudioStandard::TestPtr g_testPtrs[] = { OHOS::AudioStandard::AudioManagerFuzzTest, OHOS::AudioStandard::AudioRoutingManagerFuzzTest, OHOS::AudioStandard::AudioStreamManagerFuzzTest, @@ -193,8 +192,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) if (data == nullptr || size <= 1) { return 0; } - uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE; - if (firstByte >= OHOS::AudioStandard::TESTSIZE) { + uint32_t funcSize = sizeof(g_testPtrs) / sizeof(g_testPtrs[0]); + uint8_t firstByte = *data % funcSize; + if (firstByte >= funcSize) { return 0; } data = data + 1; diff --git a/test/fuzztest/audiomanagerstub_fuzzer/audio_manager_stub_fuzzer.cpp b/test/fuzztest/audiomanagerstub_fuzzer/audio_manager_stub_fuzzer.cpp index c36d4b8d49e4f0fa4a5f15b6193b5e7b8dfa9b06..53e707b3b093d81a3b197c9453f78171d6ad4889 100644 --- a/test/fuzztest/audiomanagerstub_fuzzer/audio_manager_stub_fuzzer.cpp +++ b/test/fuzztest/audiomanagerstub_fuzzer/audio_manager_stub_fuzzer.cpp @@ -51,7 +51,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 1; bool g_hasPermission = false; const int32_t SYSTEM_ABILITY_ID = 3001; const bool RUN_ON_CREATE = false; @@ -242,7 +241,7 @@ void OnRemoteRequestFuzzTest() audioServer->OnRemoteRequest(format, data, reply, option); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { OnRemoteRequestFuzzTest, }; diff --git a/test/fuzztest/audiomicrophonedescriptor_fuzzer/BUILD.gn b/test/fuzztest/audiomicrophonedescriptor_fuzzer/BUILD.gn index 36a416ea34d6969b58fa3621c54e4d8edf69c787..8845b7edf68f8e051a426ebfdd23d6493e36b59b 100644 --- a/test/fuzztest/audiomicrophonedescriptor_fuzzer/BUILD.gn +++ b/test/fuzztest/audiomicrophonedescriptor_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") diff --git a/test/fuzztest/audiooffloadstream_fuzzer/BUILD.gn b/test/fuzztest/audiooffloadstream_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..b6a5b133b6baaa9382724135de9840934022b0cf --- /dev/null +++ b/test/fuzztest/audiooffloadstream_fuzzer/BUILD.gn @@ -0,0 +1,69 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../accessibility.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioOffloadStreamFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audiooffloadstream_fuzzer" + + include_dirs = [ + "../../../services/audio_policy/server/include/service", + "../../../services/audio_policy/server/include", + "../../../frameworks/native/audioutils/include", + "../../../services/audio_service/common/include/limiter/", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + configs = [ "../../../services/audio_policy:audio_policy_public_config" ] + + sources = [ "audio_offload_stream_fuzzer.cpp" ] + + deps = [ + "../../../frameworks/native/audioutils:audio_utils", + "../../../services/audio_policy:audio_policy_service_static", + "../../../services/audio_service:audio_common", + ] + + external_deps = [ + "c_utils:utils", + "data_share:datashare_consumer", + "eventhandler:libeventhandler", + "hilog:libhilog", + "kv_store:distributeddata_inner", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + ] + + defines = [] + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } + + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioOffloadStreamFuzzTest" ] +} diff --git a/test/fuzztest/audiooffloadstream_fuzzer/audio_offload_stream_fuzzer.cpp b/test/fuzztest/audiooffloadstream_fuzzer/audio_offload_stream_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fa19801f11e8b2d3ad93e4ab36159c2250cdde36 --- /dev/null +++ b/test/fuzztest/audiooffloadstream_fuzzer/audio_offload_stream_fuzzer.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "../fuzz_utils.h" + +#include "audio_common_log.h" +#include "audio_offload_stream.h" + +using namespace std; + +namespace OHOS { +namespace AudioStandard { + +typedef void (*TestPtr)(); + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +static const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; + +void FuzzTestGetOffloadSessionId() +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + testModule.GetOffloadSessionId(g_fuzzUtils.GetData()); +} + +void FuzzTestSetOffloadStatus() +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + testModule.SetOffloadStatus( + g_fuzzUtils.GetData(), + g_fuzzUtils.GetData()); +} + +void FuzzTestUnsetOffloadStatus() +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + testModule.UnsetOffloadStatus(g_fuzzUtils.GetData()); +} + +void FuzzTestHandlePowerStateChanged() +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + testModule.HandlePowerStateChanged(g_fuzzUtils.GetData()); +} + +void FuzzTestUpdateOffloadStatusFromUpdateTracker() +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + testModule.UpdateOffloadStatusFromUpdateTracker( + g_fuzzUtils.GetData(), + g_fuzzUtils.GetData()); +} + +void FuzzTestDump() +{ + AudioOffloadStream &testModule = AudioOffloadStream::GetInstance(); + std::string fuzzStr = std::to_string(g_fuzzUtils.GetData()); + testModule.Dump(fuzzStr); +} + +vector g_testPtrs = { + FuzzTestGetOffloadSessionId, + FuzzTestSetOffloadStatus, + FuzzTestUnsetOffloadStatus, + FuzzTestHandlePowerStateChanged, + FuzzTestUpdateOffloadStatusFromUpdateTracker, + FuzzTestDump, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { + return 0; + } + + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testPtrs); + return 0; +} diff --git a/test/fuzztest/audiooffloadstream_fuzzer/corpus/init b/test/fuzztest/audiooffloadstream_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/audiooffloadstream_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/audiooffloadstream_fuzzer/project.xml b/test/fuzztest/audiooffloadstream_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audiooffloadstream_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioperformancemonitor_fuzzer/audio_performance_monitor_fuzzer.cpp b/test/fuzztest/audioperformancemonitor_fuzzer/audio_performance_monitor_fuzzer.cpp index 5c929b4ad72bf61ad3a7c21c5d65164656762fea..b85a01adc3f0106a242437debbb8e0ae4f4b7d11 100644 --- a/test/fuzztest/audioperformancemonitor_fuzzer/audio_performance_monitor_fuzzer.cpp +++ b/test/fuzztest/audioperformancemonitor_fuzzer/audio_performance_monitor_fuzzer.cpp @@ -37,7 +37,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 10; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -158,7 +157,7 @@ void StartSilenceMonitorFuzzTest() AudioPerformanceMonitor::GetInstance().StartSilenceMonitor(sessionId, tokenId); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { RecordSilenceStateFuzzTest, DeleteSilenceMonitorFuzzTest, ReportWriteSlowFuzzTest, diff --git a/test/fuzztest/audiopipeinfo_fuzzer/audio_pipe_info_fuzzer.cpp b/test/fuzztest/audiopipeinfo_fuzzer/audio_pipe_info_fuzzer.cpp index 435396e152f6963ebfaff136065ecea2be7da2fc..9c1b479bfb041174cf004795cbeb5b4de76904b9 100644 --- a/test/fuzztest/audiopipeinfo_fuzzer/audio_pipe_info_fuzzer.cpp +++ b/test/fuzztest/audiopipeinfo_fuzzer/audio_pipe_info_fuzzer.cpp @@ -50,7 +50,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 5; typedef void (*TestFuncs)(); @@ -128,7 +127,7 @@ void AudioPipeInfoFuzzTest() AudioPipeInfo audioPipeInfo(pipeInfo); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { DumpFuzzTest, DumpCommonAttrsFuzzTest, DumpOutputAttrsFuzzTest, diff --git a/test/fuzztest/audiopipemanager_fuzzer/audio_pipe_manager_fuzzer.cpp b/test/fuzztest/audiopipemanager_fuzzer/audio_pipe_manager_fuzzer.cpp index c0ee8213d9702d8c948c3b7a7721b165c80d5f62..7d97974442669dab3819aaddfe9dfd0eeda6abd1 100644 --- a/test/fuzztest/audiopipemanager_fuzzer/audio_pipe_manager_fuzzer.cpp +++ b/test/fuzztest/audiopipemanager_fuzzer/audio_pipe_manager_fuzzer.cpp @@ -41,7 +41,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 26; const uint32_t RESIZENUM = 2; const uint32_t IDNUM = 2; const uint32_t NUM_2 = 2; @@ -64,6 +63,7 @@ vector AudioFlagVec = { AUDIO_INPUT_FLAG_VOIP, AUDIO_INPUT_FLAG_VOIP_FAST, AUDIO_INPUT_FLAG_WAKEUP, + AUDIO_INPUT_FLAG_AI, AUDIO_FLAG_MAX, }; @@ -163,7 +163,8 @@ void GetUnusedPipeFuzzTest() pipe1->streamDescriptors_.clear(); audioPipeManager->AddAudioPipeInfo(pipe1); - audioPipeManager->GetUnusedPipe(); + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + audioPipeManager->GetUnusedPipe(deviceType); } void IsSpecialPipeFuzzTest() @@ -467,7 +468,7 @@ void GetPipeByModuleAndFlagFuzzTest() audioPipeManager->GetPipeByModuleAndFlag(targetModuleName, targetRouteFlag); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { RemoveAudioPipeInfoFuzzTest, RemoveAudioPipeInfoByIdFuzzTest, UpdateAudioPipeInfoFuzzTest, diff --git a/test/fuzztest/audiopipeselector_fuzzer/audio_pipe_selector_fuzzer.cpp b/test/fuzztest/audiopipeselector_fuzzer/audio_pipe_selector_fuzzer.cpp index 62bdba36a3abb80ef55b8a59242ba7207c258c1c..335df3be53b231fc5aef768d9d913f36259d7b6e 100644 --- a/test/fuzztest/audiopipeselector_fuzzer/audio_pipe_selector_fuzzer.cpp +++ b/test/fuzztest/audiopipeselector_fuzzer/audio_pipe_selector_fuzzer.cpp @@ -41,7 +41,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 6; const int32_t NUM_1 = 1; const uint32_t IDNUM = 100; constexpr int32_t AUDIO_MODE_COUNT = static_cast(AudioMode::AUDIO_MODE_RECORD) + NUM_1; @@ -139,6 +138,12 @@ void JudgeStreamActionFuzzTest() newPipe->adapterName_ = newAdapterName; AudioFlag newAudioFlag = static_cast(GetData() % AUDIO_FLAG_COUNT); newPipe->routeFlag_ = newAudioFlag; + std::vector className = { + "remote_offload", + "name" + }; + size_t idx = GetData() % className.size(); + newPipe->moduleInfo_.className = className[idx]; std::shared_ptr oldPipe = std::make_shared(); uint8_t oldRandomNum = GetData(); @@ -146,6 +151,8 @@ void JudgeStreamActionFuzzTest() oldPipe->adapterName_ = oldAdapterName; AudioFlag oldAudioFlag = static_cast(GetData() % AUDIO_FLAG_COUNT); oldPipe->routeFlag_ = oldAudioFlag; + idx = GetData() % className.size(); + oldPipe->moduleInfo_.className = className[idx]; auto audioPipeSelector = AudioPipeSelector::GetPipeSelector(); AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe); @@ -182,13 +189,30 @@ void FetchPipesAndExecuteFuzzTest() audioPipeSelector->FetchPipesAndExecute(streamDescs); } -TestFuncs g_testFuncs[TESTSIZE] = { +void ProcessConcurrencyFuzzTest() +{ + std::shared_ptr existingStream = std::make_shared(); + CHECK_AND_RETURN(existingStream != nullptr); + std::shared_ptr incomingStream = std::make_shared(); + CHECK_AND_RETURN(incomingStream != nullptr); + existingStream->routeFlag_ = GetData(); + existingStream->audioMode_ = GetData(); + incomingStream->routeFlag_ = GetData(); + incomingStream->audioMode_ = GetData(); + auto audioPipeSelector = AudioPipeSelector::GetPipeSelector(); + CHECK_AND_RETURN(audioPipeSelector != nullptr); + std::vector> streamsToMove; + audioPipeSelector->ProcessConcurrency(existingStream, incomingStream, streamsToMove); +} + +TestFuncs g_testFuncs[] = { GetPipeTypeFuzzTest, GetAdapterNameByStreamDescFuzzTest, ConvertStreamDescToPipeInfoFuzzTest, JudgeStreamActionFuzzTest, FetchPipeAndExecuteFuzzTest, FetchPipesAndExecuteFuzzTest, + ProcessConcurrencyFuzzTest, }; bool FuzzTest(const uint8_t* rawData, size_t size) diff --git a/test/fuzztest/audiopolicyanother_fuzzer/audio_policy_another_fuzzer.cpp b/test/fuzztest/audiopolicyanother_fuzzer/audio_policy_another_fuzzer.cpp index 19ee8426da13be2c6431bc0364afb87b194ff52e..321af37136b712cfc11f9bb5aa237cfa9a48232a 100644 --- a/test/fuzztest/audiopolicyanother_fuzzer/audio_policy_another_fuzzer.cpp +++ b/test/fuzztest/audiopolicyanother_fuzzer/audio_policy_another_fuzzer.cpp @@ -31,7 +31,6 @@ const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy"; const int32_t SYSTEM_ABILITY_ID = 3009; const bool RUN_ON_CREATE = false; const int32_t LIMITSIZE = 4; -const uint8_t TESTSIZE = 7; typedef void (*TestPtr)(const uint8_t *, size_t); AudioPolicyServer* GetServerPtr() @@ -228,9 +227,6 @@ void AudioPolicyOtherFuzzTest(const uint8_t *rawData, size_t size) int32_t sessionId = *reinterpret_cast(rawData); GetServerPtr()->GetAudioCapturerMicrophoneDescriptors(sessionId); - AudioPipeType type = *reinterpret_cast(rawData); - GetServerPtr()->MoveToNewPipe(sessionId, type); - std::shared_ptr deviceDescriptor = std::make_shared(); deviceDescriptor->deviceType_ = *reinterpret_cast(rawData); @@ -306,7 +302,7 @@ extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) return 0; } -OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = { +OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::] = { OHOS::AudioStandard::AudioVolumeFuzzTest, OHOS::AudioStandard::AudioDeviceFuzzTest, OHOS::AudioStandard::AudioInterruptFuzzTest, @@ -323,8 +319,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) if (data == nullptr || size <= 1) { return 0; } - uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE; - if (firstByte >= OHOS::AudioStandard::TESTSIZE) { + uint32_t funcSize = sizeof(g_testPtrs) / sizeof(g_testPtrs[0]); + uint8_t firstByte = *data % funcSize; + if (firstByte >= funcSize) { return 0; } data = data + 1; diff --git a/test/fuzztest/audiopolicymanager_fuzzer/audio_policy_manager_fuzzer.cpp b/test/fuzztest/audiopolicymanager_fuzzer/audio_policy_manager_fuzzer.cpp index 68863300db68796dd41658614e2d75279283cf3c..04f8456573903b8448987ed4ef17e2e15f253fa7 100644 --- a/test/fuzztest/audiopolicymanager_fuzzer/audio_policy_manager_fuzzer.cpp +++ b/test/fuzztest/audiopolicymanager_fuzzer/audio_policy_manager_fuzzer.cpp @@ -581,7 +581,6 @@ void AudioPolicyManagerDeviceTwoFuzzTest() AudioPolicyManager::GetInstance().SetPreferredDevice(preferredType, desc, uid); AudioPolicyManager::GetInstance().SetAudioDeviceAnahsCallback(audioDeviceAnahs); AudioPolicyManager::GetInstance().UnsetAudioDeviceAnahsCallback(); - AudioPolicyManager::GetInstance().MoveToNewPipe(sessionId, pipeType); AudioPolicyManager::GetInstance().SetDeviceConnectionStatus(desc, isConnected); AudioPolicyManager::GetInstance().UpdateDeviceInfo(desc, command); AudioPolicyManager::GetInstance().SetSleAudioOperationCallback(sleAudioOperationCallback); diff --git a/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/BUILD.gn b/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..464ec9d04f35a3102cda4187acb045d37146dd85 --- /dev/null +++ b/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/BUILD.gn @@ -0,0 +1,82 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioPolicyManagerListenerStubImplFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audiopolicymanagerlistenerstubimpl_fuzzer" + + include_dirs = [ + "../../../services/audio_service/common/include", + "../../../services/audio_service/server/include", + "../../../services/audio_service/client/include", + "../../../services/audio_policy/client/include", + "../../../frameworks/native/audiorenderer/include", + "../../../interfaces/inner_api", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ + "audio_policy_manager_listener_stub_impl_fuzzer.cpp", + ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + + deps = [ + "../../../services/audio_policy:audio_policy_client", + "../../../frameworks/native/audioutils:audio_utils", + "../../../services/audio_service:audio_common", + "../../../services/audio_service:audio_service", + "../../../services/audio_service:audio_process_service_static", + ] + + external_deps = [ + "ability_base:want", + "access_token:libaccesstoken_sdk", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + defines = [] + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioPolicyManagerListenerStubImplFuzzTest" ] +} diff --git a/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/audio_policy_manager_listener_stub_impl_fuzzer.cpp b/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/audio_policy_manager_listener_stub_impl_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b58e685cdd67c8eb4883744fc8f096c2446228bc --- /dev/null +++ b/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/audio_policy_manager_listener_stub_impl_fuzzer.cpp @@ -0,0 +1,195 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include "audio_policy_manager_listener_stub_impl.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +typedef void (*TestFuncs)(); + +class AudioQueryDeviceVolumeBehaviorCallbackFuzzTest : public AudioQueryDeviceVolumeBehaviorCallback { +public: + AudioQueryDeviceVolumeBehaviorCallbackFuzzTest() {} + VolumeBehavior OnQueryDeviceVolumeBehavior() override + { + VolumeBehavior volumeBehavior; + return volumeBehavior; + } +}; + +class AudioInterruptCallbackFuzzTest : public AudioInterruptCallback { +public: + AudioInterruptCallbackFuzzTest() {} + void OnInterrupt(const InterruptEventInternal &interruptEvent) override {}; +}; + +void OnInterruptFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + InterruptEventInternal interruptEvent; + policyListenerStub->OnInterrupt(interruptEvent); +} + +void OnAvailableDeviceChangeFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + DeviceChangeAction deviceChangeAction; + uint32_t usage = g_fuzzUtils.GetData(); + policyListenerStub->OnAvailableDeviceChange(usage, deviceChangeAction); +} + +void OnQueryClientTypeFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + uint32_t uid = g_fuzzUtils.GetData(); + bool ret = g_fuzzUtils.GetData(); + std::string bundleName = "bundleName"; + policyListenerStub->OnQueryClientType(bundleName, uid, ret); +} + +void OnCheckClientInfoFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::string bundleName = "bundleName"; + int32_t uid = g_fuzzUtils.GetData(); + int32_t pid = g_fuzzUtils.GetData(); + bool ret = g_fuzzUtils.GetData(); + policyListenerStub->OnCheckClientInfo(bundleName, uid, pid, ret); +} + +void OnQueryAllowedPlaybackFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + int32_t uid = g_fuzzUtils.GetData(); + int32_t pid = g_fuzzUtils.GetData(); + bool ret = g_fuzzUtils.GetData(); + policyListenerStub->OnQueryAllowedPlayback(uid, pid, ret); +} + +void OnBackgroundMuteFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + int32_t uid = g_fuzzUtils.GetData(); + policyListenerStub->OnBackgroundMute(uid); +} + +void OnQueryDeviceVolumeBehaviorFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + VolumeBehavior volumeBehavior; + policyListenerStub->OnQueryDeviceVolumeBehavior(volumeBehavior); +} + +void OnQueryBundleNameIsInListFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::string bundleName = "bundleName"; + std::string listType = "listType"; + bool ret = g_fuzzUtils.GetData(); + policyListenerStub->OnQueryBundleNameIsInList(bundleName, listType, ret); +} + +void OnRouteUpdateFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::string networkId = "networkId"; + uint32_t routeFlag = g_fuzzUtils.GetData(); + policyListenerStub->OnRouteUpdate(routeFlag, networkId); +} + +void SetInterruptCallbackFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::shared_ptr sharedCallback = + std::make_shared(); + std::weak_ptr callback(sharedCallback); + policyListenerStub->SetInterruptCallback(callback); +} + +void SetQueryClientTypeCallbackFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::shared_ptr audioQueryClientTypeCallback; + policyListenerStub->SetQueryClientTypeCallback(audioQueryClientTypeCallback); +} + +void SetAudioClientInfoMgrCallbackFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::shared_ptr audioClientInfoMgrCallback; + policyListenerStub->SetAudioClientInfoMgrCallback(audioClientInfoMgrCallback); +} + +void SetQueryBundleNameListCallbackFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::shared_ptr audioQueryBundleNameListCallback; + policyListenerStub->SetQueryBundleNameListCallback(audioQueryBundleNameListCallback); +} + +void SetQueryDeviceVolumeBehaviorCallbackFuzzTest() +{ + auto policyListenerStub = std::make_shared(); + CHECK_AND_RETURN(policyListenerStub != nullptr); + std::shared_ptr sharedCallback = + std::make_shared(); + std::weak_ptr callback(sharedCallback); + policyListenerStub->SetQueryDeviceVolumeBehaviorCallback(callback); +} + +vector g_testFuncs = { + OnInterruptFuzzTest, + OnAvailableDeviceChangeFuzzTest, + OnQueryClientTypeFuzzTest, + OnCheckClientInfoFuzzTest, + OnQueryAllowedPlaybackFuzzTest, + OnBackgroundMuteFuzzTest, + OnQueryDeviceVolumeBehaviorFuzzTest, + OnQueryBundleNameIsInListFuzzTest, + OnRouteUpdateFuzzTest, + SetInterruptCallbackFuzzTest, + SetQueryClientTypeCallbackFuzzTest, + SetQueryBundleNameListCallbackFuzzTest, + SetQueryDeviceVolumeBehaviorCallbackFuzzTest, +}; +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} \ No newline at end of file diff --git a/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/project.xml b/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audiopolicymanagerlistenerstubimpl_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audiopolicyservenhance_fuzzer/audio_policy_serv_enhance_fuzzer.cpp b/test/fuzztest/audiopolicyservenhance_fuzzer/audio_policy_serv_enhance_fuzzer.cpp index 9052718067ac98b683e014b1c5dee6857767f710..a5dc526bd3311fd48cd6928e53c9364669673125 100644 --- a/test/fuzztest/audiopolicyservenhance_fuzzer/audio_policy_serv_enhance_fuzzer.cpp +++ b/test/fuzztest/audiopolicyservenhance_fuzzer/audio_policy_serv_enhance_fuzzer.cpp @@ -180,9 +180,6 @@ void AudioPolicyServSendFuzzTest() audioPolicyServerHandler->SendHeadTrackingEnabledChangeEvent(false); audioPolicyServerHandler->SendHeadTrackingEnabledChangeForAnyDeviceEvent(selectedAudioDevice, true); audioPolicyServerHandler->SendHeadTrackingEnabledChangeForAnyDeviceEvent(selectedAudioDevice, false); - - AudioPipeType pipeType = GetData(); - audioPolicyServerHandler->SendPipeStreamCleanEvent(pipeType); } void AudioPolicyServHandleFuzzTest() diff --git a/test/fuzztest/audiopolicyserver_fuzzer/audio_policy_server_fuzzer.cpp b/test/fuzztest/audiopolicyserver_fuzzer/audio_policy_server_fuzzer.cpp index 3cdebea954c5fb061ed51b1231cf0eda6dca8af5..5deb9a9bc7e953746bd82a8747be68a489a61ff6 100644 --- a/test/fuzztest/audiopolicyserver_fuzzer/audio_policy_server_fuzzer.cpp +++ b/test/fuzztest/audiopolicyserver_fuzzer/audio_policy_server_fuzzer.cpp @@ -961,20 +961,6 @@ void AudioPolicyServerUnsetAvailableDeviceChangeCallbackFuzzTest() audioPolicyServer->UnsetAvailableDeviceChangeCallback(clientId, usageIn); } -void AudioPolicyServerOffloadStopPlayingFuzzTest() -{ - auto audioPolicyServer = GetServerPtr(); - CHECK_AND_RETURN(audioPolicyServer != nullptr); - - StreamUsage streamUsage = GetData(); - ContentType contentType = GetData(); - AudioFocusType audioFocusType = GetData(); - uint32_t streamId = GetData(); - AudioInterrupt audioInterrupt(streamUsage, contentType, audioFocusType, streamId); - - audioPolicyServer->OffloadStopPlaying(audioInterrupt); -} - void AudioPolicyServerCheckAudioSessionStrategyFuzzTest() { auto audioPolicyServer = GetServerPtr(); @@ -1680,15 +1666,6 @@ void AudioPolicyServerNotifyAccountsChangedFuzzTest() server->NotifyAccountsChanged(id); } -void AudioPolicyServerMoveToNewPipeFuzzTest() -{ - uint32_t sessionId = GetData(); - int32_t pipeType = GetData(); - auto server = GetServerPtr(); - CHECK_AND_RETURN(server != nullptr); - server->MoveToNewPipe(sessionId, pipeType); -} - void AudioPolicyServerCheckHibernateStateFuzzTest() { auto server = GetServerPtr(); @@ -2182,7 +2159,6 @@ TestFuncs g_testFuncs[] = { AudioPolicyServerGetAvailableDevicesFuzzTest, AudioPolicyServerSetAvailableDeviceChangeCallbackFuzzTest, AudioPolicyServerUnsetAvailableDeviceChangeCallbackFuzzTest, - AudioPolicyServerOffloadStopPlayingFuzzTest, AudioPolicyServerCheckAudioSessionStrategyFuzzTest, AudioPolicyServerSetAudioSessionSceneFuzzTest, AudioPolicyServerGetDefaultOutputDeviceFuzzTest, @@ -2246,7 +2222,6 @@ TestFuncs g_testFuncs[] = { AudioPolicyServerUnsetAudioDeviceAnahsCallbackFuzzTest, AudioPolicyServerSendVolumeKeyEventToRssWhenAccountsChangedFuzzTest, AudioPolicyServerNotifyAccountsChangedFuzzTest, - AudioPolicyServerMoveToNewPipeFuzzTest, AudioPolicyServerCheckHibernateStateFuzzTest, AudioPolicyServerUpdateSafeVolumeByS4FuzzTest, AudioPolicyServerCheckConnectedDeviceFuzzTest, diff --git a/test/fuzztest/audiopolicyserverhandler_fuzzer/audio_policy_server_handler_fuzzer.cpp b/test/fuzztest/audiopolicyserverhandler_fuzzer/audio_policy_server_handler_fuzzer.cpp index ae3e14b129407c8ad74d35f946a451063a06abc2..9a519f1a30d3121ed208fdbb62ea7d2d2c4a24a6 100644 --- a/test/fuzztest/audiopolicyserverhandler_fuzzer/audio_policy_server_handler_fuzzer.cpp +++ b/test/fuzztest/audiopolicyserverhandler_fuzzer/audio_policy_server_handler_fuzzer.cpp @@ -56,7 +56,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 49; static int32_t NUM_2 = 2; std::mutex paElementsMutex_; @@ -512,18 +511,6 @@ void HandleHeadTrackingEnabledChangeForAnyDeviceEventFuzzTest() audioPolicyServerHandler_->SetClientCallbacksEnable(CallbackChange::CALLBACK_SET_MICROPHONE_BLOCKED, false); audioPolicyServerHandler_->HandleHeadTrackingEnabledChangeForAnyDeviceEvent(event); } - -void HandlePipeStreamCleanEventFuzzTest() -{ - auto audioPolicyServerHandler_ = std::make_shared(); - if (audioPolicyServerHandler_ == nullptr) { - return; - } - AppExecFwk::InnerEvent::Pointer event = - AppExecFwk::InnerEvent::Get(AudioPolicyServerHandler::EventAudioServerCmd::NN_STATE_CHANGE, 0); - audioPolicyServerHandler_->SetClientCallbacksEnable(CallbackChange::CALLBACK_SET_MICROPHONE_BLOCKED, false); - audioPolicyServerHandler_->HandlePipeStreamCleanEvent(event); -} void HandleAudioZoneEventFuzzTest() { @@ -716,7 +703,7 @@ void HandleVolumeKeyEventToRssWhenAccountsChangeFuzzTest() audioPolicyServerHandler_->HandleVolumeKeyEventToRssWhenAccountsChange(eventContextObj); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { AddAudioPolicyClientProxyMapFuzzTest, RemoveAudioPolicyClientProxyMapFuzzTest, AddExternInterruptCbsMapFuzzTest, @@ -749,7 +736,6 @@ TestFuncs g_testFuncs[TESTSIZE] = { HandleSpatializatonEnabledChangeForAnyDeviceEventFuzzTest, HandleSpatializatonEnabledChangeForCurrentDeviceEventFuzzTest, HandleHeadTrackingEnabledChangeForAnyDeviceEventFuzzTest, - HandlePipeStreamCleanEventFuzzTest, HandleAudioZoneEventFuzzTest, RemoveDistributedRoutingRoleChangeCbsMapFuzzTest, HandleAudioSessionDeactiveCallbackFuzzTest, diff --git a/test/fuzztest/audiopolicyservice_fuzzer/audio_policy_service_fuzzer.cpp b/test/fuzztest/audiopolicyservice_fuzzer/audio_policy_service_fuzzer.cpp index 1be195577ca144efbaf51af48f77697a3db9e705..6fbac87bfaaee922019ab7c94b676f88a4aea492 100644 --- a/test/fuzztest/audiopolicyservice_fuzzer/audio_policy_service_fuzzer.cpp +++ b/test/fuzztest/audiopolicyservice_fuzzer/audio_policy_service_fuzzer.cpp @@ -43,7 +43,6 @@ const uint32_t LIMIT_TWO = 30; const uint32_t LIMIT_THREE = 60; const uint32_t LIMIT_FOUR = static_cast(AudioPolicyInterfaceCode::AUDIO_POLICY_MANAGER_CODE_MAX); bool g_hasServerInit = false; -const uint8_t TESTSIZE = 73; typedef void (*TestPtr)(const uint8_t *, size_t); static const uint8_t* RAW_DATA = nullptr; @@ -192,25 +191,9 @@ void AudioPolicyServiceDeviceTest(const uint8_t *rawData, size_t size) int32_t state = (num % MOD_NUM_TWO) + CONNECTING_NUMBER; // DATA_LINK_CONNECTING = 10, DATA_LINK_CONNECTED = 11; - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->UpdateOffloadWhenActiveDeviceSwitchFromA2dp(); + GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->UpdateA2dpOffloadFlagForA2dpDeviceOut(); GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->GetA2dpOffloadCodecAndSendToDsp(); GetServerPtr()->audioPolicyService_.audioMicrophoneDescriptor_.UpdateAudioCapturerMicrophoneDescriptor(deviceType); - - // the max value of BluetoothOffloadState is A2DP_OFFLOAD. - BluetoothOffloadState flag = static_cast(num % (A2DP_OFFLOAD + 1)); - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceInOffload(flag); - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceOutOffload(flag); - - uint32_t sessionId = static_cast(num); - // the max value of AudioPipeType is PIPE_TYPE_DIRECT_VOIP. - AudioPipeType pipeType = static_cast(num % (PIPE_TYPE_DIRECT_VOIP + 1)); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.MoveToNewPipeInner(sessionId, pipeType); - - GetServerPtr()->audioPolicyService_.audioOffloadStream_.LoadMchModule(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.ConstructMchAudioModuleInfo(deviceType); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.LoadOffloadModule(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.UnloadOffloadModule(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.ConstructOffloadAudioModuleInfo(deviceType); } void AudioPolicyServiceAccountTest(const uint8_t *rawData, size_t size) @@ -262,16 +245,8 @@ void AudioPolicyServiceInterfaceTest(const uint8_t *rawData, size_t size) sptr fuzzAudioRendererFilter = new AudioRendererFilter(); // set offload support on for covery - GetServerPtr()->audioPolicyService_.audioOffloadStream_.isOffloadAvailable_ = true; GetServerPtr()->audioPolicyService_.audioRecoveryDevice_.HandleRecoveryPreferredDevices(fuzzInt32One, fuzzInt32Two, fuzzInt32Three); - GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->GetVolumeGroupType(fuzzDeviceType); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.SetOffloadMode(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.ResetOffloadMode(fuzzInt32One); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.OffloadStreamReleaseCheck(fuzzInt32One); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.RemoteOffloadStreamRelease(fuzzInt32One); - GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.GetOffloadAvailableFromXml(); GetServerPtr()->audioPolicyService_.SetSourceOutputStreamMute(fuzzInt32One, fuzzBool); GetServerPtr()->audioPolicyService_.audioDeviceCommon_.IsDeviceConnected(fuzzAudioDeviceDescriptorSptr); GetServerPtr()->audioPolicyService_.audioDeviceCommon_.DeviceParamsCheck(fuzzDeviceRole, @@ -716,16 +691,6 @@ void AudioPolicyServiceInitSharedVolumeFuzztest(const uint8_t *rawData, size_t s GetServerPtr()->audioPolicyService_.InitSharedVolume(buffer); } -void AudioPolicyServiceDynamicUnloadModuleFuzztest(const uint8_t *rawData, size_t size) -{ - if (rawData == nullptr || size < LIMITSIZE) { - return; - } - - AudioPipeType pipeType = PIPE_TYPE_OFFLOAD; - GetServerPtr()->audioPolicyService_.DynamicUnloadModule(pipeType); -} - void AudioPolicyServiceGetMaxRendererInstancesFuzztest(const uint8_t *rawData, size_t size) { if (rawData == nullptr || size < LIMITSIZE) { @@ -796,22 +761,6 @@ void AudioPolicyServiceDeviceFilterByUsageInnerFuzztest(const uint8_t *rawData, GetServerPtr()->audioPolicyService_.DeviceFilterByUsageInner(usage, descs); } -void AudioPolicyServiceOffloadStartPlayingFuzztest(const uint8_t *rawData, size_t size) -{ - if (rawData == nullptr || size < LIMITSIZE) { - } - std::vector sessionIds; - GetServerPtr()->audioPolicyService_.OffloadStartPlaying(sessionIds); -} - -void AudioPolicyServiceOffloadStopPlayingFuzztest(const uint8_t *rawData, size_t size) -{ - if (rawData == nullptr || size < LIMITSIZE) { - } - std::vector sessionIds; - GetServerPtr()->audioPolicyService_.OffloadStopPlaying(sessionIds); -} - void AudioPolicyServiceOffloadGetRenderPositionFuzztest(const uint8_t *rawData, size_t size) { if (rawData == nullptr || size < LIMITSIZE) { @@ -983,7 +932,7 @@ void AudioPolicyServiceIsDevicePlaybackSupportedFuzztest(const uint8_t *rawData, } // namespace AudioStandard } // namesapce OHOS -OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = { +OHOS::AudioStandard::TestPtr g_testPtrs[] = { OHOS::AudioStandard::AudioPolicyServiceDumpTest, OHOS::AudioStandard::AudioPolicyServiceDeviceTest, OHOS::AudioStandard::AudioPolicyServiceAccountTest, @@ -1026,7 +975,6 @@ OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = { OHOS::AudioStandard::AudioPolicyServiceGetProcessDeviceInfoFuzztest, OHOS::AudioStandard::AudioPolicyServiceGetVoipDeviceInfoFuzztest, OHOS::AudioStandard::AudioPolicyServiceInitSharedVolumeFuzztest, - OHOS::AudioStandard::AudioPolicyServiceDynamicUnloadModuleFuzztest, OHOS::AudioStandard::AudioPolicyServiceGetMaxRendererInstancesFuzztest, OHOS::AudioStandard::AudioPolicyServiceRegisterBluetoothListenerFuzztest, OHOS::AudioStandard::AudioPolicyServiceUnregisterBluetoothListenerFuzztest, @@ -1035,8 +983,6 @@ OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = { OHOS::AudioStandard::AudioPolicyServiceRegisterDataObserverFuzztest, OHOS::AudioStandard::AudioPolicyServiceGetHardwareOutputSamplingRateFuzztest, OHOS::AudioStandard::AudioPolicyServiceDeviceFilterByUsageInnerFuzztest, - OHOS::AudioStandard::AudioPolicyServiceOffloadStartPlayingFuzztest, - OHOS::AudioStandard::AudioPolicyServiceOffloadStopPlayingFuzztest, OHOS::AudioStandard::AudioPolicyServiceOffloadGetRenderPositionFuzztest, OHOS::AudioStandard::AudioPolicyServiceNearlinkGetRenderPositionFuzztest, OHOS::AudioStandard::AudioPolicyServiceGetAndSaveClientTypeFuzztest, @@ -1065,8 +1011,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) if (data == nullptr || size <= 1) { return 0; } - uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE; - if (firstByte >= OHOS::AudioStandard::TESTSIZE) { + uint32_t funcSize = sizeof(g_testPtrs) / sizeof(g_testPtrs[0]); + uint8_t firstByte = *data % funcSize; + if (firstByte >= funcSize) { return 0; } data = data + 1; diff --git a/test/fuzztest/audiopolicyserviceenhance_fuzzer/BUILD.gn b/test/fuzztest/audiopolicyserviceenhance_fuzzer/BUILD.gn index 6636b8cc33a990f82d4c0238cf354e9e4603bd57..23392c849ef663fcfc9cd5d530cc71e2eb8c7518 100644 --- a/test/fuzztest/audiopolicyserviceenhance_fuzzer/BUILD.gn +++ b/test/fuzztest/audiopolicyserviceenhance_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/config/features.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") @@ -106,15 +105,6 @@ ohos_fuzztest("AudioPolicyServiceEnhanceFuzzTest") { ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - defines = [] if (audio_framework_feature_usb_audio) { @@ -180,9 +170,6 @@ ohos_fuzztest("AudioPolicyServiceEnhanceFuzzTest") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } group("fuzztest") { diff --git a/test/fuzztest/audiopolicyservicemore_fuzzer/audio_policy_service_more_fuzzer.cpp b/test/fuzztest/audiopolicyservicemore_fuzzer/audio_policy_service_more_fuzzer.cpp index 9ae468ad5d1859ae6cccbf408ad642e28e7b170a..6d19afa033c9b3af8cd0aeed30f0cdd84531a328 100644 --- a/test/fuzztest/audiopolicyservicemore_fuzzer/audio_policy_service_more_fuzzer.cpp +++ b/test/fuzztest/audiopolicyservicemore_fuzzer/audio_policy_service_more_fuzzer.cpp @@ -321,10 +321,9 @@ void AudioPolicyServiceTestII() capturerChangeInfo->capturerInfo.sourceType = SOURCE_TYPE_VIRTUAL_CAPTURE; capturerChangeInfo->capturerState = CAPTURER_PREPARED; } - GetServerPtr()->audioPolicyService_.OnReceiveBluetoothEvent( + GetServerPtr()->audioPolicyService_.OnReceiveUpdateDeviceNameEvent( GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "deviceName"); GetServerPtr()->audioPolicyService_.GetAudioEffectOffloadFlag(); - GetServerPtr()->audioPolicyService_.audioOffloadStream_.CheckSpatializationAndEffectState(); int32_t sessionId = GetData(); GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->IsA2dpOffloadConnecting(sessionId); std::vector playingStateVec = { diff --git a/test/fuzztest/audiopolicyservicespatialization_fuzzer/BUILD.gn b/test/fuzztest/audiopolicyservicespatialization_fuzzer/BUILD.gn index e45f398fc173017edae378fe0cf0d797048e4bee..8284dbc950ece75288611097d69c35626a5186a3 100644 --- a/test/fuzztest/audiopolicyservicespatialization_fuzzer/BUILD.gn +++ b/test/fuzztest/audiopolicyservicespatialization_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/config/features.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") diff --git a/test/fuzztest/audiopolicystatemonitor_fuzzer/audio_policy_state_monitor_fuzzer.cpp b/test/fuzztest/audiopolicystatemonitor_fuzzer/audio_policy_state_monitor_fuzzer.cpp index 4bd26ed3003045cca1f80d61530444187126f90b..8d889d32bc0263827fa9c7ec8129e934e3cbff3b 100644 --- a/test/fuzztest/audiopolicystatemonitor_fuzzer/audio_policy_state_monitor_fuzzer.cpp +++ b/test/fuzztest/audiopolicystatemonitor_fuzzer/audio_policy_state_monitor_fuzzer.cpp @@ -48,7 +48,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 2; static const std::time_t AUDIO_SESSION_TIME_OUT_DURATION_TEST_S = 3; typedef void (*TestFuncs)(); @@ -105,7 +104,7 @@ void FreeCbIdFuzzTest() audioPolicyStateMonitor->FreeCbId(cbId); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { UnRegisterCallbackFuzzTest, FreeCbIdFuzzTest, }; diff --git a/test/fuzztest/audioproresampler_fuzzer/BUILD.gn b/test/fuzztest/audioproresampler_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..70f7812ef7aed0e3d735c91638b5f03a71e00f75 --- /dev/null +++ b/test/fuzztest/audioproresampler_fuzzer/BUILD.gn @@ -0,0 +1,55 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("//build/ohos.gni") + +ohos_fuzztest("AudioProresamplerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioproresampler_fuzzer" + + include_dirs = [ + "../../../frameworks/native/bluetoothclient", + "../../../services/audio_engine/plugin/resample/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + configs = [ "../../../services/audio_policy:audio_policy_public_config" ] + + sources = [ "audio_proresampler_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_policy:audio_policy_service_static", + "../../../services/audio_engine:audio_engine_plugins" + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioProresamplerFuzzTest" ] +} diff --git a/test/fuzztest/audioproresampler_fuzzer/audio_proresampler_fuzzer.cpp b/test/fuzztest/audioproresampler_fuzzer/audio_proresampler_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..34f0328edbc9c2f59efd6ceff8ece2b3e723b10b --- /dev/null +++ b/test/fuzztest/audioproresampler_fuzzer/audio_proresampler_fuzzer.cpp @@ -0,0 +1,160 @@ +/* + * 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "audio_utils.h" +#include "audio_proresampler.h" +#include "audio_proresampler_process.h" +#include "../fuzz_utils.h" + +using namespace std; +namespace OHOS { +namespace AudioStandard { +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +typedef void (*TestFuncs)(); +const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; +namespace HPAE { +const uint32_t FRAME_SIZE = 1000 ; + +std::shared_ptr CreateProResampler(bool force) +{ + AudioSamplingRate inRate; + if (force) { + inRate = SAMPLE_RATE_11025; + } else { + inRate = g_fuzzUtils.GetData(); + inRate = (inRate < SAMPLE_RATE_8000) ? SAMPLE_RATE_8000 : inRate; + inRate = (inRate > SAMPLE_RATE_192000) ? SAMPLE_RATE_192000 : inRate; + } + + AudioSamplingRate outRate = g_fuzzUtils.GetData(); + outRate = (outRate < SAMPLE_RATE_8000) ? SAMPLE_RATE_8000 : outRate; + outRate = (outRate > SAMPLE_RATE_192000) ? SAMPLE_RATE_192000 : outRate; + + AudioChannel channels = g_fuzzUtils.GetData(); + channels = (channels < MONO) ? MONO : channels; + channels = (channels > CHANNEL_8) ? CHANNEL_8 : channels; + + uint32_t quality = 1; + return std::make_shared(inRate, outRate, channels, quality); +} + +void AudioProresamplerProcessFuzzTest() +{ + auto proResampler = CreateProResampler(g_fuzzUtils.GetData()); + if (proResampler == nullptr) { + return; + } + + uint32_t inFrameSize = g_fuzzUtils.GetData() % FRAME_SIZE; + uint32_t outFrameSize = g_fuzzUtils.GetData() % FRAME_SIZE; + uint32_t channels = proResampler->GetChannels(); + + std::vector inBuffer(inFrameSize * channels); + for (auto& val : inBuffer) { + val = g_fuzzUtils.GetData(); + } + std::vector outBuffer(outFrameSize * channels); + + proResampler->Process(inFrameSize > 0 ? inBuffer.data() : nullptr, inFrameSize, outBuffer.data(), outFrameSize); +} + +void AudioProresamplerUpdateRatesFuzzTest() +{ + auto proResampler = CreateProResampler(g_fuzzUtils.GetData()); + if (proResampler == nullptr) { + return; + } + + AudioSamplingRate newInRate = g_fuzzUtils.GetData(); + AudioSamplingRate newOutRate = g_fuzzUtils.GetData(); + + proResampler->UpdateRates(newInRate, newOutRate); +} + +void AudioProresamplerUpdateChannelsFuzzTest() +{ + bool ret = g_fuzzUtils.GetData(); + auto proResampler = CreateProResampler(ret); + if (proResampler == nullptr) { + return; + } + + uint32_t currentchannels = proResampler->GetChannels(); + proResampler->UpdateChannels(currentchannels); +} + +void AudioProresampleroperatorFuzzTest() +{ + ProResampler source(SAMPLE_RATE_11025, SAMPLE_RATE_48000, STEREO, 1); + ProResampler target(std::move(source)); + ProResampler movedProResampler = std::move(source); +} + +void AudioProresamplerResetFuzzTest() +{ + auto proResampler = CreateProResampler(g_fuzzUtils.GetData()); + if (proResampler == nullptr) { + return; + } + + proResampler->Reset(); +} + +void AudioProresamplerGetChannelsFuzzTest() +{ + auto proResampler = CreateProResampler(g_fuzzUtils.GetData()); + if (proResampler == nullptr) { + return; + } + + proResampler->GetChannels(); + proResampler->GetQuality(); +} + +void AudioProresamplerErrCodeToStringFuzzTest() +{ + auto proResampler = CreateProResampler(g_fuzzUtils.GetData()); + if (proResampler == nullptr) { + return; + } + + int32_t errCode = g_fuzzUtils.GetData(); + proResampler->ErrCodeToString(errCode); +} + +vector g_testFuncs = { + AudioProresamplerProcessFuzzTest, + AudioProresamplerUpdateRatesFuzzTest, + AudioProresamplerUpdateChannelsFuzzTest, + AudioProresampleroperatorFuzzTest, + AudioProresamplerResetFuzzTest, + AudioProresamplerGetChannelsFuzzTest, + AudioProresamplerErrCodeToStringFuzzTest, +}; +} // namespace HPAE +} // namespace AudioStandard +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { + return 0; + } + + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::HPAE::g_testFuncs); + return 0; +} \ No newline at end of file diff --git a/test/fuzztest/audioproresampler_fuzzer/corpus/init b/test/fuzztest/audioproresampler_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/audioproresampler_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/audioproresampler_fuzzer/project.xml b/test/fuzztest/audioproresampler_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audioproresampler_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioproresamplerprocess_fuzzer/BUILD.gn b/test/fuzztest/audioproresamplerprocess_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..624deee2416f810ee543d0d44597e2b3b926f8fa --- /dev/null +++ b/test/fuzztest/audioproresamplerprocess_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") + +ohos_fuzztest("AudioProresamplerProcessFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioproresamplerprocess_fuzzer" + + include_dirs = [ + "../../../services/audio_engine/plugin/resample/include", + "../../../interfaces/inner_api/native/audiocommon/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + sources = [ "audio_proresampler_process_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_engine:audio_engine_plugins", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "hilog:libhilog", + "os_account:os_account_innerkits", + ] +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioProresamplerProcessFuzzTest" ] +} diff --git a/test/fuzztest/audioproresamplerprocess_fuzzer/audio_proresampler_process_fuzzer.cpp b/test/fuzztest/audioproresamplerprocess_fuzzer/audio_proresampler_process_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ebc20d4c85cf74da08c08df41df47e2f98334df9 --- /dev/null +++ b/test/fuzztest/audioproresamplerprocess_fuzzer/audio_proresampler_process_fuzzer.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "audio_proresampler_process.h" +#include "audio_log.h" +#include "access_token.h" +#include "../fuzz_utils.h" +#define TWO_STEPS 2 +#define THREE_STEPS 3 +#define MAX_RATIO_INTEGRAL_METHOD 32 + +using namespace std; + +namespace OHOS { +namespace AudioStandard { + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const int32_t NUM_1 = 1; +const int32_t NUM_2 = 2; +const int32_t NUM_3 = 3; +const int32_t NUM_5 = 5; +const int32_t NUM_11 = 11; + +void GetMultiplyFilterFunFuzzTest() +{ + int32_t err = RESAMPLER_ERR_SUCCESS; + + uint32_t k = g_fuzzUtils.GetData() % NUM_5 + NUM_1; + uint32_t interpolateFactor = TWO_STEPS * k; + + uint32_t decimateFactor = interpolateFactor + NUM_1; + if (decimateFactor > MAX_RATIO_INTEGRAL_METHOD) { + decimateFactor = MAX_RATIO_INTEGRAL_METHOD; + interpolateFactor = decimateFactor - NUM_1; + interpolateFactor = (interpolateFactor / TWO_STEPS) * TWO_STEPS; + if (interpolateFactor == 0) { + return; + } + } + uint32_t numChannels = (g_fuzzUtils.GetData() % NUM_2) + NUM_1; + int32_t quality = g_fuzzUtils.GetData() % NUM_11; + SingleStagePolyphaseResamplerInit(numChannels, decimateFactor, interpolateFactor, quality, &err); +} + +void SetResamplerFunctionCoarseFuzzTest() +{ + int32_t err = RESAMPLER_ERR_SUCCESS; + + uint32_t interpolateFactor = NUM_1; + uint32_t decimateFactor = THREE_STEPS * interpolateFactor; + uint32_t numChannels = g_fuzzUtils.GetData() % NUM_3 + NUM_1; + int32_t quality = g_fuzzUtils.GetData() % NUM_11; + + SingleStagePolyphaseResamplerInit(numChannels, decimateFactor, interpolateFactor, quality, &err); +} + +vector g_testFuncs = { + GetMultiplyFilterFunFuzzTest, + SetResamplerFunctionCoarseFuzzTest, +}; + +} // namespace AudioStandard +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioproresamplerprocess_fuzzer/corpus/init b/test/fuzztest/audioproresamplerprocess_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/audioproresamplerprocess_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/audioproresamplerprocess_fuzzer/project.xml b/test/fuzztest/audioproresamplerprocess_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audioproresamplerprocess_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioqosmanager_fuzzer/audio_qosmanager_fuzzer.cpp b/test/fuzztest/audioqosmanager_fuzzer/audio_qosmanager_fuzzer.cpp index b349f965658224ae0d30039607c92a22400809b6..d459758ec9620235b2dc5f0cb9930bb2d78a077d 100644 --- a/test/fuzztest/audioqosmanager_fuzzer/audio_qosmanager_fuzzer.cpp +++ b/test/fuzztest/audioqosmanager_fuzzer/audio_qosmanager_fuzzer.cpp @@ -56,7 +56,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 2; typedef void (*TestFuncs)(); @@ -105,7 +104,7 @@ void SetThreadQosLevelWithTidFuzzTest() #endif } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { SetThreadQosLevelAsyncFuzzTest, SetThreadQosLevelWithTidFuzzTest, }; diff --git a/test/fuzztest/audiorecoverydevice_fuzzer/audio_recovery_device_fuzzer.cpp b/test/fuzztest/audiorecoverydevice_fuzzer/audio_recovery_device_fuzzer.cpp index 7f01240aa65da14a3e234216b4380af2642098d1..9ad779f83e2baa942525e2384baeeeb960c9410f 100644 --- a/test/fuzztest/audiorecoverydevice_fuzzer/audio_recovery_device_fuzzer.cpp +++ b/test/fuzztest/audiorecoverydevice_fuzzer/audio_recovery_device_fuzzer.cpp @@ -47,7 +47,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 19; typedef void (*TestFuncs)(); @@ -500,7 +499,7 @@ void AudioRecoveryDeviceWriteExcludeOutputSysEventsFuzzTest() audioRecoveryDevice->WriteExcludeOutputSysEvents(audioDevUsage, deviceDescriptor); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { RecoveryPreferredDevicesFuzzTest, RecoverExcludedOutputDevicesFuzzTest, HandleExcludedOutputDevicesRecoveryFuzzTest, diff --git a/test/fuzztest/audioresourceservice_fuzzer/BUILD.gn b/test/fuzztest/audioresourceservice_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0aeb8d2fc6aa9ede63d21bae9fffab0113c3154d --- /dev/null +++ b/test/fuzztest/audioresourceservice_fuzzer/BUILD.gn @@ -0,0 +1,85 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioResourceServiceFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioresourceservice_fuzzer" + + include_dirs = [ + "../../../frameworks/native/audioinnercall/include", + "../../../frameworks/native/hdiadapter_new/include", + "../../../services/audio_service/server/include", + "../../../services/audio_service/client/include", + "../../../services/audio_policy/client/include", + "../../../services/audio_service/common/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ "audio_resource_service_fuzzer.cpp" ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../frameworks/native/hdiadapter_new:hdiadapter_new", + "../../../services/audio_policy:audio_policy_client", + "../../../services/audio_service:audio_client", + "../../../services/audio_service:audio_common", + "../../../services/audio_service:audio_process_service_static", + "../../../services/audio_service:audio_service_static", + ] + external_deps = [ + "ability_base:want", + "access_token:libaccesstoken_sdk", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "qos_manager:concurrent_task_client", + ] + + defines = [] + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } +} + +group("fuzztest") { + testonly = true + deps = [] + if (audio_framework_feature_low_latency) { + deps += [ ":AudioResourceServiceFuzzTest" ] + } +} diff --git a/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp b/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5140345861473afa9b7ada6c495010b772f69f00 --- /dev/null +++ b/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp @@ -0,0 +1,134 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_resource_service.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy"; +const int32_t TEST_RTG_ID = 2; + +typedef void (*TestFuncs)(); + +class RemoteObjectTestStub : public IRemoteObject { +public: + RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {} + int32_t GetObjectRefCount() { return 0; }; + int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; }; + bool AddDeathRecipient(const sptr &recipient) { return true; }; + bool RemoveDeathRecipient(const sptr &recipient) { return true; }; + int Dump(int fd, const std::vector &args) { return 0; }; +}; + +void ResourceServiceCreateAudioWorkgroupFuzzTest() +{ + int32_t pid = g_fuzzUtils.GetData(); + MessageParcel data; + data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN); + sptr remoteObject = data.ReadRemoteObject(); + if (remoteObject == nullptr) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + audioResourceService->CreateAudioWorkgroup(pid, remoteObject); +} + +void ResourceServiceAudioWorkgroupDeathRecipientFuzzTest() +{ + AudioResourceService::AudioWorkgroupDeathRecipient deathRecipient; + std::function diedCb = []() { + }; + deathRecipient.diedCb_ = diedCb; + deathRecipient.OnRemoteDied(nullptr); +} + +void ResourceServiceSetNotifyCbFuzzTest() +{ + AudioResourceService::AudioWorkgroupDeathRecipient deathRecipient; + std::function func = []() { + }; + + deathRecipient.diedCb_ = func; + deathRecipient.SetNotifyCb(func); +} + +void ResourceServiceOnWorkgroupRemoteDiedFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + sptr remoteObj = nullptr; + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + audioResourceService->audioWorkgroupMap_[1].groups[TEST_RTG_ID] = {workgroup}; + audioResourceService->OnWorkgroupRemoteDied(workgroup, remoteObj); +} + +void ResourceServiceReleaseWorkgroupDeathRecipientFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + sptr remoteObj = new RemoteObjectTestStub(); + AudioResourceService::GetInstance()->ReleaseWorkgroupDeathRecipient(workgroup, remoteObj); +} + +void ResourceServiceWorkgroupRendererMonitorFuzzTest() +{ + auto audioResourceService = AudioResourceService::GetInstance(); + int32_t testPid = g_fuzzUtils.GetData(); + if (audioResourceService == nullptr) { + return; + } + audioResourceService->audioWorkgroupMap_[testPid].permission = g_fuzzUtils.GetData(); + audioResourceService->WorkgroupRendererMonitor(testPid, true); +} + +void ResourceServiceDumpAudioWorkgroupMapFuzzTest() +{ + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + audioResourceService->DumpAudioWorkgroupMap(); +} + +vector g_testFuncs = { + ResourceServiceCreateAudioWorkgroupFuzzTest, + ResourceServiceAudioWorkgroupDeathRecipientFuzzTest, + ResourceServiceSetNotifyCbFuzzTest, + ResourceServiceOnWorkgroupRemoteDiedFuzzTest, + ResourceServiceReleaseWorkgroupDeathRecipientFuzzTest, + ResourceServiceWorkgroupRendererMonitorFuzzTest, + ResourceServiceDumpAudioWorkgroupMapFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioresourceservice_fuzzer/corpus/init b/test/fuzztest/audioresourceservice_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/audioresourceservice_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/audioresourceservice_fuzzer/project.xml b/test/fuzztest/audioresourceservice_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audioresourceservice_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioschedule_fuzzer/audio_schedule_fuzzer.cpp b/test/fuzztest/audioschedule_fuzzer/audio_schedule_fuzzer.cpp index a4853daff5ffb03fbc8c6c0dcaa1aaee450156a5..d16a50887c06850582ded35809c9557312482349 100644 --- a/test/fuzztest/audioschedule_fuzzer/audio_schedule_fuzzer.cpp +++ b/test/fuzztest/audioschedule_fuzzer/audio_schedule_fuzzer.cpp @@ -57,7 +57,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 5; typedef void (*TestFuncs)(); @@ -127,7 +126,7 @@ void ResetEndpointThreadPriorityFuzzTest() #endif } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { ResetProcessDataThreadPriorityFuzzTest, SetProcessDataThreadPriorityFuzzTest, OnAddResSchedServiceFuzzTest, diff --git a/test/fuzztest/audioservermore_fuzzer/audio_server_more_fuzzer.cpp b/test/fuzztest/audioservermore_fuzzer/audio_server_more_fuzzer.cpp index 1f78cda616195a1d7a1377afe58cf4bfa423989c..06e2a7fecdd238825b7e811cd261f3c450fa99a0 100644 --- a/test/fuzztest/audioservermore_fuzzer/audio_server_more_fuzzer.cpp +++ b/test/fuzztest/audioservermore_fuzzer/audio_server_more_fuzzer.cpp @@ -918,6 +918,19 @@ void AudioServerRemoveThreadFromGroupFuzzTest(const uint8_t *rawData, size_t siz audioServerPtr->RemoveThreadFromGroup(pid, workgroupId, tokenId); } +void AudioServerGetVolumeBySessionIdFuzzTest(const uint8_t *rawData, size_t size) +{ + if (rawData == nullptr || size < LIMITSIZE) { + return; + } + uint32_t sessionId = GetData(); + float volume = GetData(); + AudioRendererDataTransferStateChangeInfo info; + std::shared_ptr audioServerPtr = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + CHECK_AND_RETURN(audioServerPtr != nullptr); + audioServerPtr->GetVolumeBySessionId(sessionId, volume); +} + } // namespace AudioStandard } // namesapce OHOS @@ -969,5 +982,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::AudioStandard::AudioServerHpaeDumpOnDumpSinkInputsInfoCbFuzzTest(data, size); OHOS::AudioStandard::AudioServerHpaeDumpSourceOutputsInfoCbFuzzTest(data, size); OHOS::AudioStandard::AudioServerRemoveThreadFromGroupFuzzTest(data, size); + OHOS::AudioStandard::AudioServerGetVolumeBySessionIdFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/audioserverproxy_fuzzer/BUILD.gn b/test/fuzztest/audioserverproxy_fuzzer/BUILD.gn index eed3bb842565e7f1d79b55e55e5c4e5cf2fbfcd6..281be542de3ca5aecc4a128168eda23d30c95768 100644 --- a/test/fuzztest/audioserverproxy_fuzzer/BUILD.gn +++ b/test/fuzztest/audioserverproxy_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") diff --git a/test/fuzztest/audioserviceserversrc_fuzzer/audio_service_server_src_fuzzer.cpp b/test/fuzztest/audioserviceserversrc_fuzzer/audio_service_server_src_fuzzer.cpp index 511b2888f8ef694139347bde8646c9ce28a2714b..48ef699cd6134d7677edb54c031ab08b3177384f 100644 --- a/test/fuzztest/audioserviceserversrc_fuzzer/audio_service_server_src_fuzzer.cpp +++ b/test/fuzztest/audioserviceserversrc_fuzzer/audio_service_server_src_fuzzer.cpp @@ -34,6 +34,7 @@ #include "audio_playback_engine.h" #include "pro_renderer_stream_impl.h" #include "oh_audio_buffer.h" +#include "../fuzz_utils.h" using namespace std; namespace OHOS { @@ -41,40 +42,14 @@ namespace AudioStandard { constexpr int32_t DEFAULT_STREAM_ID = 10; static std::unique_ptr playbackEngine_ = nullptr; static std::unique_ptr audioPlaybackEngine_ = nullptr; -static const uint8_t* RAW_DATA = nullptr; -static size_t g_dataSize = 0; -static size_t g_pos; -const size_t THRESHOLD = 10; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +constexpr int32_t REQUEST_DATA_LEN = 3; +typedef void (*TestFuncs)(); /* * describe: get data from outside untrusted data(g_data) which size is according to sizeof(T) * tips: only support basic type */ -template -T GetData() -{ - T object {}; - size_t objectSize = sizeof(object); - if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) { - return object; - } - errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize); - if (ret != EOK) { - return {}; - } - g_pos += objectSize; - return object; -} - -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); -} void ReleaseNoneEngine() { @@ -100,7 +75,7 @@ void DeviceFuzzTestSetUp() AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); deviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET; playbackEngine_ = std::make_unique(); - bool isVoip = GetData(); + bool isVoip = g_fuzzUtils.GetData(); playbackEngine_->Init(deviceInfo, isVoip); ReleaseNoneEngine(); } @@ -125,7 +100,7 @@ void DirectAudioPlayBackEngineStateFuzzTest() AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); rendererStream->InitParams(); - uint32_t num = GetData(); + uint32_t num = g_fuzzUtils.GetData(); rendererStream->SetStreamIndex(num); rendererStream->Start(); rendererStream->Pause(); @@ -167,7 +142,7 @@ void NoneMixEngineAddRendererFuzzTest() AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); rendererStream->InitParams(); - uint32_t num = GetData(); + uint32_t num = g_fuzzUtils.GetData(); rendererStream->SetStreamIndex(num); rendererStream->Start(); playbackEngine_ = std::make_unique(); @@ -180,7 +155,7 @@ void NoneMixEngineRemoveRendererFuzzTest() AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); rendererStream->InitParams(); - uint32_t num = GetData(); + uint32_t num = g_fuzzUtils.GetData(); rendererStream->SetStreamIndex(num); rendererStream->Start(); playbackEngine_ = std::make_unique(); @@ -197,7 +172,7 @@ void PlaybackEngineInitFuzzTest() AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO); deviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET; audioPlaybackEngine_ = std::make_unique(); - bool isVoip = GetData(); + bool isVoip = g_fuzzUtils.GetData(); audioPlaybackEngine_->Init(deviceInfo, isVoip); ReleaseAudioPlaybackEngine(); } @@ -249,7 +224,7 @@ void PlaybackEngineAddRendererFuzzTest() AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); rendererStream->InitParams(); - uint32_t num = GetData(); + uint32_t num = g_fuzzUtils.GetData(); rendererStream->SetStreamIndex(num); rendererStream->Start(); audioPlaybackEngine_ = std::make_unique(); @@ -262,7 +237,7 @@ void PlaybackEngineRemoveRendererFuzzTest() AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); rendererStream->InitParams(); - uint32_t num = GetData(); + uint32_t num = g_fuzzUtils.GetData(); rendererStream->SetStreamIndex(num); rendererStream->Start(); audioPlaybackEngine_ = std::make_unique(); @@ -273,79 +248,79 @@ void PlaybackEngineRemoveRendererFuzzTest() void ResourceServiceAudioWorkgroupCheckFuzzTest() { - int32_t pid = GetData(); + int32_t pid = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->AudioWorkgroupCheck(pid); } void ResourceServiceCreateAudioWorkgroupFuzzTest() { - int32_t pid = GetData(); + int32_t pid = g_fuzzUtils.GetData(); sptr remoteObject = nullptr; AudioResourceService::GetInstance()->CreateAudioWorkgroup(pid, remoteObject); } void ResourceServiceReleaseAudioWorkgroupFuzzTest() { - int32_t pid = GetData(); - int32_t workgroupId = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->ReleaseAudioWorkgroup(pid, workgroupId); } void ResourceServiceAddThreadToGroupFuzzTest() { - int32_t pid = GetData(); - int32_t workgroupId = GetData(); - int32_t tokenId = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + int32_t tokenId = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->AddThreadToGroup(pid, workgroupId, tokenId); } void ResourceServiceRemoveThreadFromGroupFuzzTest() { - int32_t pid = GetData(); - int32_t workgroupId = GetData(); - int32_t tokenId = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + int32_t tokenId = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->RemoveThreadFromGroup(pid, workgroupId, tokenId); } void ResourceServiceStartGroupFuzzTest() { - int32_t pid = GetData(); - int32_t workgroupId = GetData(); - uint64_t startTime = GetData(); - uint64_t deadlineTime = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + uint64_t startTime = g_fuzzUtils.GetData(); + uint64_t deadlineTime = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->StartGroup(pid, workgroupId, startTime, deadlineTime); } void ResourceServiceStopGroupFuzzTest() { - int32_t pid = GetData(); - int32_t workgroupId = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->StopGroup(pid, workgroupId); } void ResourceServiceGetAudioWorkgroupPtrFuzzTest() { - int32_t pid = GetData(); - int32_t workgroupId = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->GetAudioWorkgroupPtr(pid, workgroupId); } void ResourceServiceGetThreadsNumPerProcessFuzzTest() { - int32_t pid = GetData(); + int32_t pid = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->GetThreadsNumPerProcess(pid); } void ResourceServiceIsProcessHasSystemPermissionFuzzTest() { - int32_t pid = GetData(); + int32_t pid = g_fuzzUtils.GetData(); AudioResourceService::GetInstance()->IsProcessHasSystemPermission(pid); } void ResourceServiceRegisterAudioWorkgroupMonitorFuzzTest() { - int32_t pid = GetData(); - int32_t groupId = GetData(); + int32_t pid = g_fuzzUtils.GetData(); + int32_t groupId = g_fuzzUtils.GetData(); sptr object = nullptr; AudioResourceService::GetInstance()->RegisterAudioWorkgroupMonitor(pid, groupId, object); } @@ -371,6 +346,9 @@ void RenderInServerHandleOperationStartedFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + renderer->standByEnable_ = g_fuzzUtils.GetData(); renderer->HandleOperationStarted(); } @@ -407,9 +385,9 @@ void RenderInServerGetStandbyStatusFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; - - bool isStandby = GetData(); - int64_t enterStandbyTime = GetData(); + + bool isStandby = g_fuzzUtils.GetData(); + int64_t enterStandbyTime = g_fuzzUtils.GetData(); renderer->GetStandbyStatus(isStandby, enterStandbyTime); } @@ -422,10 +400,13 @@ void RenderInServerWriteMuteDataSysEventFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + BufferDesc desc; desc.buffer = nullptr; desc.bufLength = 0; - desc.dataLength =0; + desc.dataLength = 0; + renderer->isInSilentState_ = g_fuzzUtils.GetData(); renderer->WriteMuteDataSysEvent(desc); } @@ -438,12 +419,18 @@ void RenderInServerInnerCaptureEnqueueBufferFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + BufferDesc bufferDesc; bufferDesc.buffer = nullptr; bufferDesc.bufLength = 0; - bufferDesc.dataLength =0; + bufferDesc.dataLength = 0; CaptureInfo captureInfo; - int32_t innerCapId = GetData(); + AudioProcessConfig audioProcessConfig; + audioProcessConfig.streamType = STREAM_MUSIC; + captureInfo.dupStream = std::make_shared(audioProcessConfig, true); + int32_t innerCapId = g_fuzzUtils.GetData(); + renderer->renderEmptyCountForInnerCap_ = g_fuzzUtils.GetData(); renderer->InnerCaptureEnqueueBuffer(bufferDesc, captureInfo, innerCapId); } @@ -461,7 +448,7 @@ void RenderInServerInnerCaptureOtherStreamFuzzTest() bufferDesc.bufLength = 0; bufferDesc.dataLength =0; CaptureInfo captureInfo; - int32_t innerCapId = GetData(); + int32_t innerCapId = g_fuzzUtils.GetData(); renderer->InnerCaptureOtherStream(bufferDesc, captureInfo, innerCapId); } @@ -474,12 +461,14 @@ void RenderInServerOtherStreamEnqueueFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; - + CHECK_AND_RETURN(renderer != nullptr); + unsigned char inputData[] = "test"; BufferDesc bufferDesc; bufferDesc.buffer = inputData; bufferDesc.bufLength = 0; bufferDesc.dataLength =0; + renderer->isDualToneEnabled_ = g_fuzzUtils.GetData(); renderer->OtherStreamEnqueue(bufferDesc); } @@ -492,7 +481,7 @@ void RenderInServerIsInvalidBufferFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; - + unsigned char inputData[] = "test"; BufferDesc bufferDesc; bufferDesc.buffer = inputData; @@ -510,7 +499,7 @@ void RenderInServerDualToneStreamInStartFuzzTest() std::shared_ptr rendererInServer = std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; - + renderer->dualToneStreamInStart(); } @@ -524,7 +513,7 @@ void RenderInServerRecordStandbyTimeFuzzTest() std::make_shared(processConfig, streamListener); std::shared_ptr renderer = rendererInServer; bool isStandby = false; - bool isStandbyStart = GetData(); + bool isStandbyStart = g_fuzzUtils.GetData(); renderer->RecordStandbyTime(isStandby, isStandbyStart); } @@ -532,7 +521,7 @@ void ProRendererGetStreamFramesWrittenFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - uint64_t framesWritten = GetData(); + uint64_t framesWritten = g_fuzzUtils.GetData(); rendererStream->GetStreamFramesWritten(framesWritten); } @@ -540,7 +529,7 @@ void ProRendererGetCurrentTimeStampFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - uint64_t timestamp = GetData(); + uint64_t timestamp = g_fuzzUtils.GetData(); rendererStream->GetCurrentTimeStamp(timestamp); } @@ -548,10 +537,10 @@ void ProRendererGetCurrentPositionFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - uint64_t framePosition = GetData(); - uint64_t timestamp = GetData(); - uint64_t latency = GetData(); - uint32_t base = GetData(); + uint64_t framePosition = g_fuzzUtils.GetData(); + uint64_t timestamp = g_fuzzUtils.GetData(); + uint64_t latency = g_fuzzUtils.GetData(); + uint32_t base = g_fuzzUtils.GetData(); rendererStream->GetCurrentPosition(framePosition, timestamp, latency, base); } @@ -559,7 +548,7 @@ void ProRendererGetLatencyFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - uint64_t latency = GetData(); + uint64_t latency = g_fuzzUtils.GetData(); rendererStream->GetLatency(latency); } @@ -567,7 +556,7 @@ void ProRendererSetAudioEffectModeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t effectMode = GetData(); + int32_t effectMode = g_fuzzUtils.GetData(); rendererStream->SetAudioEffectMode(effectMode); } @@ -575,7 +564,7 @@ void ProRendererGetAudioEffectModeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t effectMode = GetData(); + int32_t effectMode = g_fuzzUtils.GetData(); rendererStream->GetAudioEffectMode(effectMode); } @@ -583,7 +572,7 @@ void ProRendererSetPrivacyTypeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t privacyType = GetData(); + int32_t privacyType = g_fuzzUtils.GetData(); rendererStream->SetPrivacyType(privacyType); } @@ -591,7 +580,7 @@ void ProRendererGetPrivacyTypeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t privacyType = GetData(); + int32_t privacyType = g_fuzzUtils.GetData(); rendererStream->GetPrivacyType(privacyType); } @@ -599,7 +588,7 @@ void ProRendererSetSpeedFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - float speed = GetData(); + float speed = g_fuzzUtils.GetData(); rendererStream->SetSpeed(speed); } @@ -607,7 +596,7 @@ void ProRendererDequeueBufferFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - size_t length = GetData(); + size_t length = g_fuzzUtils.GetData(); rendererStream->DequeueBuffer(length); } @@ -626,7 +615,7 @@ void ProRendererGetMinimumBufferSizeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - size_t minBufferSize = GetData(); + size_t minBufferSize = g_fuzzUtils.GetData(); rendererStream->GetMinimumBufferSize(minBufferSize); } @@ -634,7 +623,7 @@ void ProRendererGetByteSizePerFrameFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - size_t byteSizePerFrame = GetData(); + size_t byteSizePerFrame = g_fuzzUtils.GetData(); rendererStream->GetByteSizePerFrame(byteSizePerFrame); } @@ -642,7 +631,7 @@ void ProRendererGetSpanSizePerFrameFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - size_t spanSizeInFrame = GetData(); + size_t spanSizeInFrame = g_fuzzUtils.GetData(); rendererStream->GetSpanSizePerFrame(spanSizeInFrame); } @@ -657,7 +646,7 @@ void ProRendererOffloadSetVolumeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - float volume = GetData(); + float volume = g_fuzzUtils.GetData(); rendererStream->OffloadSetVolume(volume); } @@ -665,16 +654,16 @@ void ProRendererSetOffloadDataCallbackStateFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t state = GetData(); + int32_t state = g_fuzzUtils.GetData(); rendererStream->SetOffloadDataCallbackState(state); } - + void ProRendererUpdateSpatializationStateFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - bool spatializationEnabled = GetData(); - bool headTrackingEnabled = GetData(); + bool spatializationEnabled = g_fuzzUtils.GetData(); + bool headTrackingEnabled = g_fuzzUtils.GetData(); rendererStream->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled); } @@ -682,9 +671,9 @@ void ProRendererGetAudioTimeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - uint64_t framePos = GetData(); - int64_t sec = GetData(); - int64_t nanoSec = GetData(); + uint64_t framePos = g_fuzzUtils.GetData(); + int64_t sec = g_fuzzUtils.GetData(); + int64_t nanoSec = g_fuzzUtils.GetData(); rendererStream->GetAudioTime(framePos, sec, nanoSec); } @@ -692,7 +681,7 @@ void ProRendererPeekFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t index = GetData(); + int32_t index = g_fuzzUtils.GetData(); std::vector audioBuffer = {0x01, 0x02, 0x03, 0x04, 0x05}; rendererStream->Peek(&audioBuffer, index); } @@ -701,7 +690,7 @@ void ProRendererReturnIndexFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t index = GetData(); + int32_t index = g_fuzzUtils.GetData(); rendererStream->ReturnIndex(index); } @@ -709,7 +698,7 @@ void ProRendererSetClientVolumeFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - float clientVolume = GetData(); + float clientVolume = g_fuzzUtils.GetData(); rendererStream->SetClientVolume(clientVolume); } @@ -717,7 +706,7 @@ void ProRendererSetLoudnessGainFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - float loudnessGain = GetData(); + float loudnessGain = g_fuzzUtils.GetData(); rendererStream->SetLoudnessGain(loudnessGain); } @@ -725,7 +714,7 @@ void ProRendererUpdateMaxLengthFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - uint32_t maxLength = GetData(); + uint32_t maxLength = g_fuzzUtils.GetData(); rendererStream->UpdateMaxLength(maxLength); } @@ -733,7 +722,7 @@ void ProRendererPopSinkBufferFuzzTest() { AudioProcessConfig config = InitProcessConfig(); std::shared_ptr rendererStream = std::make_shared(config, true); - int32_t index = GetData(); + int32_t index = g_fuzzUtils.GetData(); std::vector audioBuffer = {0x01, 0x02, 0x03, 0x04, 0x05}; rendererStream->PopSinkBuffer(&audioBuffer, index); } @@ -745,9 +734,245 @@ void ProRendererGetStreamVolumeFuzzTest() rendererStream->GetStreamVolume(); } -typedef void (*TestFuncs[66])(); +void ReConfigDupStreamCallbackFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + renderer->dupTotalSizeInFrame_ = g_fuzzUtils.GetData(); + renderer->ReConfigDupStreamCallback(); +} + +void DoFadingOutFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + RingBufferWrapper bufferDesc; + renderer->DoFadingOut(bufferDesc); +} + +void PrepareOutputBufferFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + RingBufferWrapper bufferDesc; + renderer->PrepareOutputBuffer(bufferDesc); +} + +void CopyDataToInputBufferFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + int8_t inPutData[REQUEST_DATA_LEN]; + RingBufferWrapper ringBufferDesc; + renderer->CopyDataToInputBuffer(inPutData, REQUEST_DATA_LEN, ringBufferDesc); +} + +void OnWriteDataFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + size_t length = g_fuzzUtils.GetData(); + renderer->OnWriteData(length); +} + +void PauseFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + renderer->standByEnable_ = g_fuzzUtils.GetData(); + renderer->Pause(); +} + +void DisableAllInnerCapFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + renderer->DisableAllInnerCap(); +} + +void OnStatusUpdateFuzzTest() +{ + uint32_t streamIndex = g_fuzzUtils.GetData(); + auto StreamCallbacksPtr = std::make_shared(streamIndex); + CHECK_AND_RETURN(StreamCallbacksPtr != nullptr); + + IOperation operation = g_fuzzUtils.GetData(); + StreamCallbacksPtr->OnStatusUpdate(operation); +} + +void OnWriteDataStreamsCallbackFuzzTest() +{ + uint32_t streamIndex = g_fuzzUtils.GetData(); + auto StreamCallbacksPtr = std::make_shared(streamIndex); + CHECK_AND_RETURN(StreamCallbacksPtr != nullptr); + + size_t length = g_fuzzUtils.GetData(); + StreamCallbacksPtr->OnWriteData(length); +} + +void GetAvailableSizeStreamsCallbackFuzzTest() +{ + uint32_t streamIndex = g_fuzzUtils.GetData(); + auto StreamCallbacksPtr = std::make_shared(streamIndex); + CHECK_AND_RETURN(StreamCallbacksPtr != nullptr); + + size_t length = g_fuzzUtils.GetData(); + StreamCallbacksPtr->GetAvailableSize(length); +} + +void IsHighResolutionFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + renderer->IsHighResolution(); +} + +void SetMuteFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + bool isMute = g_fuzzUtils.GetData(); + renderer->SetMute(isMute); +} + +void SetDuckFactorFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + float duckFactor = g_fuzzUtils.GetData(); + renderer->SetDuckFactor(duckFactor); +} + +void SetDefaultOutputDeviceFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + DeviceType defaultOutputDevice = g_fuzzUtils.GetData(); + renderer->SetDefaultOutputDevice(defaultOutputDevice); +} + +void SetSpeedFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + float speed = g_fuzzUtils.GetData(); + renderer->SetSpeed(speed); +} + +void StopSessionFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + renderer->StopSession(); +} + +void InitDupBufferFuzzTest() +{ + AudioProcessConfig processConfig; + std::shared_ptr streamListenerHolder = + std::make_shared(); + std::weak_ptr streamListener = streamListenerHolder; + std::shared_ptr rendererInServer = + std::make_shared(processConfig, streamListener); + std::shared_ptr renderer = rendererInServer; + CHECK_AND_RETURN(renderer != nullptr); + + int32_t innerCapId = g_fuzzUtils.GetData(); + renderer->InitDupBuffer(innerCapId); +} -TestFuncs g_testFuncs = { +vector g_testFuncs = { DeviceFuzzTestSetUp, DirectAudioPlayBackEngineStateFuzzTest, NoneMixEngineStartFuzzTest, @@ -814,39 +1039,30 @@ TestFuncs g_testFuncs = { ProRendererUpdateMaxLengthFuzzTest, ProRendererPopSinkBufferFuzzTest, ProRendererGetStreamVolumeFuzzTest, + ReConfigDupStreamCallbackFuzzTest, + DoFadingOutFuzzTest, + PrepareOutputBufferFuzzTest, + CopyDataToInputBufferFuzzTest, + OnWriteDataFuzzTest, + PauseFuzzTest, + DisableAllInnerCapFuzzTest, + OnStatusUpdateFuzzTest, + OnWriteDataStreamsCallbackFuzzTest, + GetAvailableSizeStreamsCallbackFuzzTest, + IsHighResolutionFuzzTest, + SetMuteFuzzTest, + SetDuckFactorFuzzTest, + SetDefaultOutputDeviceFuzzTest, + SetSpeedFuzzTest, + StopSessionFuzzTest, + InitDupBufferFuzzTest, }; - -bool FuzzTest(const uint8_t* rawData, size_t size) -{ - if (rawData == nullptr) { - return false; - } - - // initialize data - RAW_DATA = rawData; - g_dataSize = size; - g_pos = 0; - - uint32_t code = GetData(); - uint32_t len = GetArrLength(g_testFuncs); - if (len > 0) { - g_testFuncs[code % len](); - } else { - AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__); - } - - return true; -} } // namespace AudioStandard -} // namesapce OHOS +} // namespace OHOS /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size < OHOS::AudioStandard::THRESHOLD) { - return 0; - } - - OHOS::AudioStandard::FuzzTest(data, size); + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); return 0; -} +} \ No newline at end of file diff --git a/test/fuzztest/audiospatializationservice_fuzzer/audio_spatialization_service_fuzzer.cpp b/test/fuzztest/audiospatializationservice_fuzzer/audio_spatialization_service_fuzzer.cpp index c5d4fe3da2353e44c919f29c32619853c584422c..4fb21fdafaf9a1afecbcd39b4755727f0bf889b8 100644 --- a/test/fuzztest/audiospatializationservice_fuzzer/audio_spatialization_service_fuzzer.cpp +++ b/test/fuzztest/audiospatializationservice_fuzzer/audio_spatialization_service_fuzzer.cpp @@ -50,7 +50,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 24; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -446,7 +445,7 @@ void AudioSpatializationServiceSetSpatializationSceneTypeFuzzTest() ptrAudioSpatializationService->SetSpatializationSceneType(spatializationSceneType); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { UpdateCurrentDeviceFuzzTest, RemoveOldestDeviceFuzzTest, UpdateDeviceSpatialMapInfoFuzzTest, diff --git a/test/fuzztest/audiostatemanager_fuzzer/audio_state_manager_fuzzer.cpp b/test/fuzztest/audiostatemanager_fuzzer/audio_state_manager_fuzzer.cpp index 76e704473b3be6552f9f17a43275249c066464d9..92a0f2925bd5b0384e6bb71bef411d98700ccea9 100644 --- a/test/fuzztest/audiostatemanager_fuzzer/audio_state_manager_fuzzer.cpp +++ b/test/fuzztest/audiostatemanager_fuzzer/audio_state_manager_fuzzer.cpp @@ -43,7 +43,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 15; typedef void (*TestFuncs)(); @@ -214,8 +213,7 @@ void SetAndGetPreferredCallRenderDeviceTypeNotEqTypeNoneFuzzTest() AudioStateManager::GetAudioStateManager().GetPreferredCallRenderDevice(); } - -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { SetPreferredMediaRenderDeviceFuzzTest, SetAndGetRecordCaptureDeviceFuzzTest, SetPreferredCallCaptureDeviceFuzzTest, diff --git a/test/fuzztest/audiostreamdescriptor_fuzzer/audio_stream_descriptor_fuzzer.cpp b/test/fuzztest/audiostreamdescriptor_fuzzer/audio_stream_descriptor_fuzzer.cpp index 6d21785323faaefc237b6ebf7260fe5c58a5f318..316db4777546b2eaa364ad0eb82478025114fa7d 100644 --- a/test/fuzztest/audiostreamdescriptor_fuzzer/audio_stream_descriptor_fuzzer.cpp +++ b/test/fuzztest/audiostreamdescriptor_fuzzer/audio_stream_descriptor_fuzzer.cpp @@ -56,7 +56,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 14; typedef void (*TestFuncs)(); @@ -248,7 +247,7 @@ void GetNewDevicesInfoFuzzTest() streamDesc->GetNewDevicesInfo(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { MarshallingFuzzTest, UnmarshallingFuzzTest, WriteDeviceDescVectorToParcelFuzzTest, diff --git a/test/fuzztest/audiovolume_fuzzer/audio_volume_fuzzer.cpp b/test/fuzztest/audiovolume_fuzzer/audio_volume_fuzzer.cpp index 507b52ff5ab449b603bf08d650d6e653de1f5297..cb16785578710d50b71c679e78197e30e6084746 100644 --- a/test/fuzztest/audiovolume_fuzzer/audio_volume_fuzzer.cpp +++ b/test/fuzztest/audiovolume_fuzzer/audio_volume_fuzzer.cpp @@ -29,7 +29,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 27; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -370,7 +369,7 @@ void SetVgsVolumeSupportedFuzzTest() AudioVolume::GetInstance()->SetVgsVolumeSupported(GetData() % NUM_2); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { GetVolumeFuzzTest, GetDoNotDisturbStatusVolumeFuzzTest, SetDoNotDisturbStatusWhiteListVolumeFuzzTest, diff --git a/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp b/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp index d78e1654bccb7cfdb037d3d093f34e540cdfaf3f..7a49ea4fae19cec1ad503cd5e535b15a6487c26c 100644 --- a/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp +++ b/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp @@ -14,94 +14,18 @@ */ #include "audio_volume_manager.h" +#include "../fuzz_utils.h" using namespace std; namespace OHOS { namespace AudioStandard { -const int32_t NUM_2 = 2; -const int32_t SAFE_VOLUME_LIMIT = 100; -const int32_t RESTORE_VOLUME_NOTIFICATION_ID = 116000; -const int32_t INCREASE_VOLUME_NOTIFICATION_ID = 116001; -const uint32_t NOTIFICATION_BANNER_FLAG = 1 << 9; -typedef void (*TestPtr)(const uint8_t *, size_t); - -const vector g_testStreamTypes = { - STREAM_DEFAULT, - STREAM_VOICE_CALL, - STREAM_MUSIC, - STREAM_RING, - STREAM_MEDIA, - STREAM_VOICE_ASSISTANT, - STREAM_SYSTEM, - STREAM_ALARM, - STREAM_NOTIFICATION, - STREAM_BLUETOOTH_SCO, - STREAM_ENFORCED_AUDIBLE, - STREAM_DTMF, - STREAM_TTS, - STREAM_ACCESSIBILITY, - STREAM_RECORDING, - STREAM_MOVIE, - STREAM_GAME, - STREAM_SPEECH, - STREAM_SYSTEM_ENFORCED, - STREAM_ULTRASONIC, - STREAM_WAKEUP, - STREAM_VOICE_MESSAGE, - STREAM_NAVIGATION, - STREAM_INTERNAL_FORCE_STOP, - STREAM_SOURCE_VOICE_CALL, - STREAM_VOICE_COMMUNICATION, - STREAM_VOICE_RING, - STREAM_VOICE_CALL_ASSISTANT, - STREAM_CAMCORDER, - STREAM_APP, - STREAM_TYPE_MAX, - STREAM_ALL, -}; - -const vector g_testDeviceTypes = { - DEVICE_TYPE_NONE, - DEVICE_TYPE_INVALID, - DEVICE_TYPE_EARPIECE, - DEVICE_TYPE_SPEAKER, - DEVICE_TYPE_WIRED_HEADSET, - DEVICE_TYPE_WIRED_HEADPHONES, - DEVICE_TYPE_BLUETOOTH_SCO, - DEVICE_TYPE_BLUETOOTH_A2DP, - DEVICE_TYPE_BLUETOOTH_A2DP_IN, - DEVICE_TYPE_MIC, - DEVICE_TYPE_WAKEUP, - DEVICE_TYPE_USB_HEADSET, - DEVICE_TYPE_DP, - DEVICE_TYPE_REMOTE_CAST, - DEVICE_TYPE_USB_DEVICE, - DEVICE_TYPE_ACCESSORY, - DEVICE_TYPE_REMOTE_DAUDIO, - DEVICE_TYPE_HDMI, - DEVICE_TYPE_LINE_DIGITAL, - DEVICE_TYPE_NEARLINK, - DEVICE_TYPE_NEARLINK_IN, - DEVICE_TYPE_FILE_SINK, - DEVICE_TYPE_FILE_SOURCE, - DEVICE_TYPE_EXTERN_CABLE, - DEVICE_TYPE_DEFAULT, - DEVICE_TYPE_USB_ARM_HEADSET, - DEVICE_TYPE_MAX -}; - -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); -} +const std::string AUDIO_RESTORE_VOLUME_EVENT = "AUDIO_RESTORE_VOLUME_EVENT"; +const std::string AUDIO_INCREASE_VOLUME_EVENT = "AUDIO_INCREASE_VOLUME_EVENT"; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +typedef void (*TestPtr)(); -void AudioVolumeManagerInitSharedVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitSharedVolumeFuzzTest() { std::shared_ptr buffer; AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); @@ -109,252 +33,171 @@ void AudioVolumeManagerInitSharedVolumeFuzzTest(const uint8_t *rawData, size_t s audioVolumeManager.InitSharedVolume(buffer); } -void AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest() { - bool isMute = static_cast(static_cast(size) % NUM_2); + bool isMute = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.SetVoiceRingtoneMute(isMute); } -void AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest() { std::string macAddress = "11:22:33:44:55:66"; - int32_t volumeLevel = static_cast(size); - AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); - vector testDeviceCategory = { - CATEGORY_DEFAULT, - BT_HEADPHONE, - BT_SOUNDBOX, - BT_CAR, - BT_GLASSES, - BT_WATCH, - BT_HEARAID, - BT_UNWEAR_HEADPHONE, - }; - - audioVolumeManager.isBtFirstBoot_ = static_cast(static_cast(size) % NUM_2); - uint32_t index = static_cast(size) % testDeviceCategory.size(); - audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = testDeviceCategory[index]; + int32_t volumeLevel = g_fuzzUtils.GetData(); + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + audioVolumeManager.isBtFirstBoot_ = g_fuzzUtils.GetData(); + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = g_fuzzUtils.GetData(); audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel); } -void AudioVolumeManagerIsWiredHeadSetFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerIsWiredHeadSetFuzzTest() { - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; + DeviceType deviceType = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.IsWiredHeadSet(deviceType); } -void AudioVolumeManagerIsBlueToothFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerIsBlueToothFuzzTest() { - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; + DeviceType deviceType = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.IsBlueTooth(deviceType); } -void AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest() { - int32_t safeVolume = static_cast(size) % SAFE_VOLUME_LIMIT; + int32_t safeVolume = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); - audioVolumeManager.activeSafeTimeBt_ = static_cast(size); - audioVolumeManager.activeSafeTime_ = static_cast(size); + audioVolumeManager.activeSafeTimeBt_ = 0; + audioVolumeManager.activeSafeTime_ = g_fuzzUtils.GetData(); audioVolumeManager.CheckMixActiveMusicTime(safeVolume); } -void AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest() { - int32_t safeVolume = static_cast(size) % SAFE_VOLUME_LIMIT; + int32_t safeVolume = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.startSafeTimeBt_ = 0; - audioVolumeManager.activeSafeTimeBt_ = static_cast(size); - audioVolumeManager.activeSafeTime_ = static_cast(size); + audioVolumeManager.activeSafeTimeBt_ = 0; + audioVolumeManager.activeSafeTime_ = g_fuzzUtils.GetData(); audioVolumeManager.CheckBlueToothActiveMusicTime(safeVolume); } -void AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest() { - int32_t safeVolume = static_cast(size) % SAFE_VOLUME_LIMIT; + int32_t safeVolume = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.startSafeTimeBt_ = 0; - audioVolumeManager.activeSafeTimeBt_ = static_cast(size); - audioVolumeManager.activeSafeTime_ = static_cast(size); + audioVolumeManager.activeSafeTimeBt_ = 0; + audioVolumeManager.activeSafeTime_ = g_fuzzUtils.GetData(); audioVolumeManager.CheckWiredActiveMusicTime(safeVolume); } -void AudioVolumeManagerRestoreSafeVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerRestoreSafeVolumeFuzzTest() { - uint32_t index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamType = g_testStreamTypes[index]; - int32_t safeVolume = static_cast(size) % SAFE_VOLUME_LIMIT; + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t safeVolume = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.RestoreSafeVolume(streamType, safeVolume); } -void AudioVolumeManagerSetSafeVolumeCallbackFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetSafeVolumeCallbackFuzzTest() { - uint32_t index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamType = g_testStreamTypes[index]; + AudioStreamType streamType = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.audioPolicyServerHandler_ = std::make_shared(); audioVolumeManager.SetSafeVolumeCallback(streamType); } -void AudioVolumeManagerChangeDeviceSafeStatusFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerChangeDeviceSafeStatusFuzzTest() { - vector testSafeStatus = { - SAFE_UNKNOWN, - SAFE_INACTIVE, - SAFE_ACTIVE, - }; - - uint32_t index = static_cast(size) % testSafeStatus.size(); - SafeStatus safeStatus = testSafeStatus[index]; + SafeStatus safeStatus = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.ChangeDeviceSafeStatus(safeStatus); } -void AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest() { std::string macAddress = "11:22:33:44:55:66"; - bool support = static_cast(static_cast(size) % NUM_2); + bool support = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress); audioVolumeManager.SetAbsVolumeSceneAsync(macAddress, support); } -void AudioVolumeManagerDealWithEventVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerDealWithEventVolumeFuzzTest() { - vector testNotificationIds = { - RESTORE_VOLUME_NOTIFICATION_ID, - INCREASE_VOLUME_NOTIFICATION_ID, - NOTIFICATION_BANNER_FLAG, - }; - uint32_t index = static_cast(size) % testNotificationIds.size(); - int32_t notificationId = testNotificationIds[index]; + int32_t notificationId = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); - - vector testDeviceCategory = { - CATEGORY_DEFAULT, - BT_HEADPHONE, - BT_SOUNDBOX, - BT_CAR, - BT_GLASSES, - BT_WATCH, - BT_HEARAID, - BT_UNWEAR_HEADPHONE, - }; - index = static_cast(size) % testDeviceCategory.size(); - audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = testDeviceCategory[index]; - - index = static_cast(size) % g_testDeviceTypes.size(); - audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_testDeviceTypes[index]; - + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = g_fuzzUtils.GetData(); + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioVolumeManager.DealWithEventVolume(notificationId); } -void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest() { AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.UpdateSafeVolumeByS4(); } -void AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest() { std::string macAddress = "11:22:33:44:55:66"; - bool support = static_cast(static_cast(size) % NUM_2); + bool support = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress); audioVolumeManager.SetDeviceAbsVolumeSupported(macAddress, support); } -void AudioVolumeManagerSetStreamMuteFuzzTest(const uint8_t *rawData, size_t size) -{ - vector testStreamUsages = { - STREAM_USAGE_INVALID, - STREAM_USAGE_UNKNOWN, - STREAM_USAGE_MEDIA, - STREAM_USAGE_MUSIC, - STREAM_USAGE_VOICE_COMMUNICATION, - STREAM_USAGE_VOICE_ASSISTANT, - STREAM_USAGE_ALARM, - STREAM_USAGE_VOICE_MESSAGE, - STREAM_USAGE_NOTIFICATION_RINGTONE, - STREAM_USAGE_RINGTONE, - STREAM_USAGE_NOTIFICATION, - STREAM_USAGE_ACCESSIBILITY, - STREAM_USAGE_SYSTEM, - STREAM_USAGE_MOVIE, - STREAM_USAGE_GAME, - STREAM_USAGE_AUDIOBOOK, - STREAM_USAGE_NAVIGATION, - STREAM_USAGE_DTMF, - STREAM_USAGE_ENFORCED_TONE, - STREAM_USAGE_ULTRASONIC, - STREAM_USAGE_VIDEO_COMMUNICATION, - STREAM_USAGE_RANGING, - STREAM_USAGE_VOICE_MODEM_COMMUNICATION, - STREAM_USAGE_VOICE_RINGTONE, - STREAM_USAGE_VOICE_CALL_ASSISTANT, - STREAM_USAGE_MAX, - }; - uint32_t index = static_cast(size) % g_testStreamTypes.size(); - AudioVolumeType streamType = g_testStreamTypes[index]; - bool mute = static_cast(static_cast(size) % NUM_2); - AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); - - index = static_cast(size) % testStreamUsages.size(); - StreamUsage streamUsage = testStreamUsages[index]; - index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; +void AudioVolumeManagerSetStreamMuteFuzzTest() +{ + AudioVolumeType streamType = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + StreamUsage streamUsage = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + std::string macAddress = "11:22:33:44:55:66"; + audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress); + A2dpDeviceConfigInfo a2dpDeviceConfigInfo; + a2dpDeviceConfigInfo.absVolumeSupport = g_fuzzUtils.GetData(); + audioVolumeManager.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({macAddress, a2dpDeviceConfigInfo}); audioVolumeManager.SetStreamMute(streamType, mute, streamUsage, deviceType); } -void AudioVolumeManagerGetMaxVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetMaxVolumeLevelFuzzTest() { - uint32_t index = static_cast(size) % g_testStreamTypes.size(); - AudioVolumeType streamType = g_testStreamTypes[index]; + AudioVolumeType streamType = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.GetMaxVolumeLevel(streamType); } -void AudioVolumeManagerGetMinVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetMinVolumeLevelFuzzTest() { - uint32_t index = static_cast(size) % g_testStreamTypes.size(); - AudioVolumeType streamType = g_testStreamTypes[index]; + AudioVolumeType streamType = g_fuzzUtils.GetData(); AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.GetMinVolumeLevel(streamType); } -void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest() { - vector testDeviceRoles = { - DEVICE_ROLE_NONE, - INPUT_DEVICE, - OUTPUT_DEVICE, - DEVICE_ROLE_MAX, - }; auto audioVolumeManager = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; - index = static_cast(size) % testDeviceRoles.size(); - DeviceRole deviceRole = testDeviceRoles[index]; + DeviceType deviceType = g_fuzzUtils.GetData(); + DeviceRole deviceRole = g_fuzzUtils.GetData(); std::shared_ptr remoteDeviceDescriptor = std::make_shared( deviceType, deviceRole); @@ -362,7 +205,7 @@ void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest(const uint8_t *rawData, si audioVolumeManager->GetAllDeviceVolumeInfo(); } -void AudioVolumeManagerInitFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitFuzzTest() { AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); std::shared_ptr audioPolicyServerHandler = std::make_shared(); @@ -371,64 +214,220 @@ void AudioVolumeManagerInitFuzzTest(const uint8_t *rawData, size_t size) audioVolumeManager.Init(audioPolicyServerHandler); } -void AudioVolumeManagerInitKVStoreFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitKVStoreFuzzTest() { AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); audioVolumeManager.InitKVStore(); } -void AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest() { AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); - audioVolumeManager.ForceVolumeKeyControlType(static_cast(size), size); + AudioVolumeType volumeType = g_fuzzUtils.GetData(); + int32_t duration = g_fuzzUtils.GetData(); + audioVolumeManager.forceControlVolumeTypeMonitor_ = make_shared(); + audioVolumeManager.ForceVolumeKeyControlType(volumeType, duration); } -} // namespace AudioStandard -} // namesapce OHOS +void AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + int32_t zoneId = g_fuzzUtils.GetData(); + audioVolumeManager.SetAdjustVolumeForZone(zoneId); +} + +void AudioVolumeManagerGetSystemVolumeLevelFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t zoneId = g_fuzzUtils.GetData(); + bool flag = g_fuzzUtils.GetData(); + audioVolumeManager.SetRingerModeMute(flag); + audioVolumeManager.GetSystemVolumeLevel(streamType, zoneId); +} + +void AudioVolumeManagerCheckToCloseNotificationFuzzTest() +{ + bool isPCVolumeEnable = g_fuzzUtils.GetData(); + VolumeUtils::SetPCVolumeEnable(isPCVolumeEnable); + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); + audioVolumeManager.increaseNIsShowing_ = g_fuzzUtils.GetData(); + audioVolumeManager.restoreNIsShowing_ = g_fuzzUtils.GetData(); + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); + audioVolumeManager.CheckToCloseNotification(streamType, volumeLevel); +} + +void AudioVolumeManagerSetAppVolumeMutedFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + int32_t appUid = g_fuzzUtils.GetData(); + bool muted = g_fuzzUtils.GetData(); + audioVolumeManager.SetAppVolumeMuted(appUid, muted); +} + +void AudioVolumeManagerIsAppVolumeMuteFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + int32_t appUid = g_fuzzUtils.GetData(); + bool owned = g_fuzzUtils.GetData(); + bool isMute; + audioVolumeManager.IsAppVolumeMute(appUid, owned, isMute); +} + +void AudioVolumeManagerHandleNearlinkDeviceAbsVolumeFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); + DeviceType curOutputDeviceType = g_fuzzUtils.GetData(); + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.macAddress_ = "11:22:33:44:55:66"; + bool isClear = g_fuzzUtils.GetData(); + if (isClear) { + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.macAddress_.clear(); + } + audioVolumeManager.HandleNearlinkDeviceAbsVolume(streamType, volumeLevel, curOutputDeviceType); +} + +void AudioVolumeManagerSetA2dpDeviceVolumeFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + std::string macAddress = "11:22:33:44:55:66"; + int32_t volumeLevel = g_fuzzUtils.GetData(); + bool internalCall = g_fuzzUtils.GetData(); + bool isAdd = g_fuzzUtils.GetData(); + A2dpDeviceConfigInfo a2dpDeviceConfigInfo; + if (isAdd) { + audioVolumeManager.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({macAddress, a2dpDeviceConfigInfo}); + } + audioVolumeManager.SetA2dpDeviceVolume(macAddress, volumeLevel, internalCall); + audioVolumeManager.audioA2dpDevice_.connectedA2dpDeviceMap_.clear(); +} + +void AudioVolumeManagerCancelSafeVolumeNotificationFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + int32_t notificationId = g_fuzzUtils.GetData(); + audioVolumeManager.CancelSafeVolumeNotification(notificationId); +} + +void AudioVolumeManagerSetRestoreVolumeLevelFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + DeviceType deviceType = g_fuzzUtils.GetData(); + int32_t curDeviceVolume = g_fuzzUtils.GetData(); + audioVolumeManager.SetRestoreVolumeLevel(deviceType, curDeviceVolume); +} -OHOS::AudioStandard::TestPtr g_testPtrs[] = { - OHOS::AudioStandard::AudioVolumeManagerInitSharedVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerIsWiredHeadSetFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerIsBlueToothFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerRestoreSafeVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetSafeVolumeCallbackFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerChangeDeviceSafeStatusFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerDealWithEventVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetStreamMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetMaxVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetMinVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitKVStoreFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest, +void AudioVolumeManagerCheckLowerDeviceVolumeFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + DeviceType deviceType = g_fuzzUtils.GetData(); + audioVolumeManager.CheckLowerDeviceVolume(deviceType); +} + +void AudioVolumeManagerOnReceiveEventFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + AAFwk::Want want; + EventFwk::CommonEventData eventData; + std::string action; + bool isRestore = g_fuzzUtils.GetData(); + if (isRestore) { + action = AUDIO_RESTORE_VOLUME_EVENT; + } else { + action = AUDIO_INCREASE_VOLUME_EVENT; + } + want.SetAction(action); + eventData.SetWant(want); + audioVolumeManager.OnReceiveEvent(eventData); +} + +void AudioVolumeManagerSetDeviceSafeVolumeStatusFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + audioVolumeManager.userSelect_ = g_fuzzUtils.GetData(); + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); + audioVolumeManager.SetDeviceSafeVolumeStatus(); +} + +void AudioVolumeManagerDisableSafeMediaVolumeFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + audioVolumeManager.DisableSafeMediaVolume(); +} + +void AudioVolumeManagerResetRingerModeMuteFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + audioVolumeManager.ResetRingerModeMute(); +} + +void AudioVolumeManagerGetLoadFlagFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + bool isLoad = g_fuzzUtils.GetData(); + audioVolumeManager.SetDefaultDeviceLoadFlag(isLoad); + audioVolumeManager.GetLoadFlag(); +} + +void AudioVolumeManagerOnTimerExpiredFuzzTest() +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + audioVolumeManager.OnTimerExpired(); + audioVolumeManager.GetForceControlVolumeType(); +} + +vector g_testFuncs = { + AudioVolumeManagerInitSharedVolumeFuzzTest, + AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest, + AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest, + AudioVolumeManagerIsWiredHeadSetFuzzTest, + AudioVolumeManagerIsBlueToothFuzzTest, + AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest, + AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest, + AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest, + AudioVolumeManagerRestoreSafeVolumeFuzzTest, + AudioVolumeManagerSetSafeVolumeCallbackFuzzTest, + AudioVolumeManagerChangeDeviceSafeStatusFuzzTest, + AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest, + AudioVolumeManagerDealWithEventVolumeFuzzTest, + AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest, + AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest, + AudioVolumeManagerSetStreamMuteFuzzTest, + AudioVolumeManagerGetMaxVolumeLevelFuzzTest, + AudioVolumeManagerGetMinVolumeLevelFuzzTest, + AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest, + AudioVolumeManagerInitFuzzTest, + AudioVolumeManagerInitKVStoreFuzzTest, + AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest, + AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest, + AudioVolumeManagerGetSystemVolumeLevelFuzzTest, + AudioVolumeManagerCheckToCloseNotificationFuzzTest, + AudioVolumeManagerSetAppVolumeMutedFuzzTest, + AudioVolumeManagerIsAppVolumeMuteFuzzTest, + AudioVolumeManagerHandleNearlinkDeviceAbsVolumeFuzzTest, + AudioVolumeManagerSetA2dpDeviceVolumeFuzzTest, + AudioVolumeManagerCancelSafeVolumeNotificationFuzzTest, + AudioVolumeManagerSetRestoreVolumeLevelFuzzTest, + AudioVolumeManagerCheckLowerDeviceVolumeFuzzTest, + AudioVolumeManagerOnReceiveEventFuzzTest, + AudioVolumeManagerSetDeviceSafeVolumeStatusFuzzTest, + AudioVolumeManagerDisableSafeMediaVolumeFuzzTest, + AudioVolumeManagerResetRingerModeMuteFuzzTest, + AudioVolumeManagerGetLoadFlagFuzzTest, + AudioVolumeManagerOnTimerExpiredFuzzTest, }; +} // namespace AudioStandard +} // namesapce OHOS + /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - /* Run your code on data */ - if (data == nullptr || size <= 1) { - return 0; - } - uint32_t len = OHOS::AudioStandard::GetArrLength(g_testPtrs); - if (len > 0) { - uint8_t firstByte = *data % len; - if (firstByte >= len) { - return 0; - } - data = data + 1; - size = size - 1; - g_testPtrs[firstByte](data, size); - } + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); return 0; } \ No newline at end of file diff --git a/test/fuzztest/audioxmlparser_fuzzer/audio_xml_parser_fuzzer.cpp b/test/fuzztest/audioxmlparser_fuzzer/audio_xml_parser_fuzzer.cpp index 8bec6306b74be9baf5379a00935994ee4a520b54..99eecd2bec31e15f775524fe793a7de6fa325316 100644 --- a/test/fuzztest/audioxmlparser_fuzzer/audio_xml_parser_fuzzer.cpp +++ b/test/fuzztest/audioxmlparser_fuzzer/audio_xml_parser_fuzzer.cpp @@ -57,7 +57,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 3; typedef void (*TestFuncs)(); @@ -115,7 +114,7 @@ void OperatorFuzzTest() shared_ptr ptr2 = ptr1; } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { HasPropFuzzTest, GetContentFuzzTest, OperatorFuzzTest, diff --git a/test/fuzztest/audiozone_fuzzer/BUILD.gn b/test/fuzztest/audiozone_fuzzer/BUILD.gn index 4e443bd9f7c56a24737437cafe93154b5fc8877d..ad3ff3d116680c5b84ead7bda755868377872e48 100644 --- a/test/fuzztest/audiozone_fuzzer/BUILD.gn +++ b/test/fuzztest/audiozone_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") @@ -150,15 +149,6 @@ ohos_fuzztest("AudioZoneFuzzTest") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -177,9 +167,6 @@ ohos_fuzztest("AudioZoneFuzzTest") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } group("fuzztest") { diff --git a/test/fuzztest/audiozoneclientmanager_fuzzer/BUILD.gn b/test/fuzztest/audiozoneclientmanager_fuzzer/BUILD.gn index 0475b262a0c450c5bc62e4dfaec02ed7722bb365..a4819b0f8eb076bb2eabf210778fbb30e0c15e3d 100644 --- a/test/fuzztest/audiozoneclientmanager_fuzzer/BUILD.gn +++ b/test/fuzztest/audiozoneclientmanager_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") @@ -150,15 +149,6 @@ ohos_fuzztest("AudioZoneClientManagerFuzzTest") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -177,9 +167,6 @@ ohos_fuzztest("AudioZoneClientManagerFuzzTest") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } group("fuzztest") { diff --git a/test/fuzztest/audiozoneservice_fuzzer/BUILD.gn b/test/fuzztest/audiozoneservice_fuzzer/BUILD.gn index cf53f691deabdd4fa886bc8e5d44039b618a1c1b..334b22d1a65ce91c7a7da8ef4f46f30ac557698f 100644 --- a/test/fuzztest/audiozoneservice_fuzzer/BUILD.gn +++ b/test/fuzztest/audiozoneservice_fuzzer/BUILD.gn @@ -15,7 +15,6 @@ import("//build/ohos.gni") import("//build/test.gni") import("../../../accessibility.gni") import("../../../appgallery.gni") -import("../../../av_session.gni") import("../../../bluetooth_part.gni") import("../../../config.gni") @@ -150,15 +149,6 @@ ohos_fuzztest("AudioZoneServiceFuzzTest") { external_deps += [ "bluetooth:btframework" ] } - if (avsession_part_enable == true) { - external_deps += [ - "ability_base:want", - "ability_runtime:wantagent_innerkits", - "av_session:avsession_client", - "input:libmmi-client", - ] - } - if (audio_framework_feature_input) { defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] external_deps += [ "input:libmmi-client" ] @@ -177,9 +167,6 @@ ohos_fuzztest("AudioZoneServiceFuzzTest") { cflags += [ "-DBLUETOOTH_ENABLE" ] } - if (avsession_part_enable == true) { - cflags += [ "-DAVSESSION_ENABLE" ] - } } group("fuzztest") { diff --git a/test/fuzztest/bluetoothdevicemanager_fuzzer/BUILD.gn b/test/fuzztest/bluetoothdevicemanager_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..198255e8123d7d13e104a67de69e5f1cd336fd2b --- /dev/null +++ b/test/fuzztest/bluetoothdevicemanager_fuzzer/BUILD.gn @@ -0,0 +1,67 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("BluetoothDeviceManagerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../bluetoothdevicemanager_fuzzer" + + include_dirs = [ + "../../../frameworks/native/bluetoothclient", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ + "bluetooth_device_manager_fuzzer.cpp", + "../../../frameworks/native/bluetoothclient/bluetooth_device_manager.cpp", + "../../../frameworks/native/bluetoothclient/bluetooth_device_utils.cpp", + ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../frameworks/native/bluetoothclient:audio_bluetooth_client", + "../../../services/audio_policy:audio_foundation", + "../../../frameworks/native/audioutils:audio_utils", + ] + external_deps = [ + "access_token:libaccesstoken_sdk", + "bluetooth:btframework", + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_single", + "qos_manager:concurrent_task_client", + "safwk:system_ability_fwk", + ] + + defines = [] + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":BluetoothDeviceManagerFuzzTest" ] +} diff --git a/test/fuzztest/bluetoothdevicemanager_fuzzer/bluetooth_device_manager_fuzzer.cpp b/test/fuzztest/bluetoothdevicemanager_fuzzer/bluetooth_device_manager_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f122e3871a562ec05538fb5ba331e29c49fcdec7 --- /dev/null +++ b/test/fuzztest/bluetoothdevicemanager_fuzzer/bluetooth_device_manager_fuzzer.cpp @@ -0,0 +1,266 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "bluetooth_device_manager.h" +#include "bluetooth_device_utils.h" +#include "audio_info.h" +#include "audio_engine_log.h" +#include "idevice_status_observer.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; +using namespace Bluetooth; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const int32_t TRANSPORT = 2; +const string DEFAULT_BLUETOOTH_MAC_ADDRESS = "00:11:22:33:44:55"; + +typedef void (*TestFuncs)(); + +class DummyDeviceStatusObserver : public IDeviceStatusObserver { +public: + void OnDeviceStatusUpdated(DeviceType devType, bool isConnected, + const std::string &macAddress, const std::string &deviceName, + const AudioStreamInfo &streamInfo, DeviceRole role = DEVICE_ROLE_NONE, bool hasPair = false) override {} + + void OnMicrophoneBlockedUpdate(DeviceType devType, DeviceBlockStatus status) override {} + + void OnPnpDeviceStatusUpdated(AudioDeviceDescriptor &desc, bool isConnected) override {} + + void OnDeviceConfigurationChanged(DeviceType deviceType, + const std::string &macAddress, const std::string &deviceName, + const AudioStreamInfo &streamInfo) override {} + + void OnDeviceStatusUpdated(DStatusInfo statusInfo, bool isStop = false) override {} + + void OnServiceConnected(AudioServiceIndex serviceIndex) override {} + + void OnServiceDisconnected(AudioServiceIndex serviceIndex) override {} + + void OnForcedDeviceSelected(DeviceType devType, const std::string &macAddress) override {} + + void OnDeviceStatusUpdated(AudioDeviceDescriptor &desc, bool isConnected) override {} + + void OnDeviceInfoUpdated(AudioDeviceDescriptor &desc, const DeviceInfoUpdateCommand updateCommand) override {} +}; + +void RegisterDeviceObserverFuzzTest() +{ + DummyDeviceStatusObserver observer; + RegisterDeviceObserver(observer); + UnregisterDeviceObserver(); +} + +void SetMediaStackFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + int32_t action = g_fuzzUtils.GetData(); + + MediaBluetoothDeviceManager deviceManager; + deviceManager.SetMediaStack(device, action); +} + +void SendUserSelectionEventFuzzTest() +{ + DeviceType devType = g_fuzzUtils.GetData(); + std::string macAddress = DEFAULT_BLUETOOTH_MAC_ADDRESS; + int32_t eventType = g_fuzzUtils.GetData(); + SendUserSelectionEvent(devType, macAddress, eventType); +} + +void NotifyToUpdateAudioDeviceFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + AudioDeviceDescriptor desc; + DeviceStatus status = g_fuzzUtils.GetData(); + MediaBluetoothDeviceManager deviceManager; + deviceManager.NotifyToUpdateAudioDevice(device, desc, status); +} + +void IsA2dpBluetoothDeviceConnectingFuzzTest() +{ + MediaBluetoothDeviceManager deviceManager; + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + bool isConnect = g_fuzzUtils.GetData(); + int32_t action = g_fuzzUtils.GetData(); + if (isConnect) { + deviceManager.SetMediaStack(device, action); + } + deviceManager.IsA2dpBluetoothDeviceConnecting(DEFAULT_BLUETOOTH_MAC_ADDRESS); +} + +void UpdateA2dpDeviceConfigurationFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + AudioStreamInfo streamInfo; + MediaBluetoothDeviceManager deviceManager; + deviceManager.UpdateA2dpDeviceConfiguration(device, streamInfo); + deviceManager.GetAllA2dpBluetoothDevice(); + deviceManager.GetA2dpVirtualDeviceList(); + deviceManager.ClearAllA2dpBluetoothDevice(); +} + +void SetA2dpInStackFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + int32_t action = g_fuzzUtils.GetData(); + + AudioStreamInfo streamInfo; + + A2dpInBluetoothDeviceManager deviceManager; + deviceManager.SetA2dpInStack(device, streamInfo, action); +} + +void A2dpInNotifyToUpdateAudioDeviceFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + AudioStreamInfo streamInfo; + AudioDeviceDescriptor desc; + DeviceStatus status = g_fuzzUtils.GetData(); + A2dpInBluetoothDeviceManager deviceManager; + deviceManager.NotifyToUpdateAudioDevice(device, streamInfo, desc, status); +} + +void GetA2dpInDeviceStreamInfoFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + std::vector macAddresses = { + DEFAULT_BLUETOOTH_MAC_ADDRESS, + "AA:BB:CC:DD:EE:FF", + "12:34:56:78:9A:BC" + }; + size_t idx = g_fuzzUtils.GetData() % macAddresses.size(); + + AudioStreamInfo streamInfo; + A2dpInBluetoothDeviceManager deviceManager; + int32_t action = g_fuzzUtils.GetData(); + deviceManager.SetA2dpInStack(device, streamInfo, action); + + deviceManager.GetA2dpInDeviceStreamInfo(macAddresses[idx], streamInfo); +} + +void GetAllA2dpInBluetoothDeviceFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + AudioStreamInfo streamInfo; + A2dpInBluetoothDeviceManager deviceManager; + deviceManager.GetAllA2dpInBluetoothDevice(); + deviceManager.ClearAllA2dpInBluetoothDevice(); + deviceManager.ClearAllA2dpInStreamInfo(); +} + +void SetHfpStackFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + int32_t action = g_fuzzUtils.GetData(); + + HfpBluetoothDeviceManager deviceManager; + deviceManager.SetHfpStack(device, action); +} + +void HfpNotifyToUpdateAudioDeviceFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + AudioDeviceDescriptor desc; + DeviceStatus status = g_fuzzUtils.GetData(); + HfpBluetoothDeviceManager deviceManager; + deviceManager.NotifyToUpdateAudioDevice(device, desc, status); +} + +void IsHfpBluetoothDeviceConnectingFuzzTest() +{ + HfpBluetoothDeviceManager deviceManager; + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + bool isConnect = g_fuzzUtils.GetData(); + int32_t action = g_fuzzUtils.GetData(); + if (isConnect) { + deviceManager.SetHfpStack(device, action); + } + + deviceManager.IsHfpBluetoothDeviceConnecting(DEFAULT_BLUETOOTH_MAC_ADDRESS); +} + +void GetConnectedHfpBluetoothDeviceFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + std::vector macAddresses = { + DEFAULT_BLUETOOTH_MAC_ADDRESS, + "AA:BB:CC:DD:EE:FF", + "12:34:56:78:9A:BC" + }; + size_t idx = g_fuzzUtils.GetData() % macAddresses.size(); + + HfpBluetoothDeviceManager deviceManager; + int32_t action = g_fuzzUtils.GetData(); + deviceManager.SetHfpStack(device, action); + deviceManager.GetConnectedHfpBluetoothDevice(macAddresses[idx], device); +} + +void GetAllHfpBluetoothDeviceFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + HfpBluetoothDeviceManager deviceManager; + deviceManager.GetAllHfpBluetoothDevice(); + deviceManager.GetHfpVirtualDeviceList(); + deviceManager.ClearAllHfpBluetoothDevice(); +} + +void OnScoStateChangedFuzzTest() +{ + BluetoothRemoteDevice device(DEFAULT_BLUETOOTH_MAC_ADDRESS, TRANSPORT); + HfpBluetoothDeviceManager deviceManager; + bool isScoConnected = g_fuzzUtils.GetData(); + int32_t reason = g_fuzzUtils.GetData(); + deviceManager.OnScoStateChanged(device, isScoConnected, reason); +} + +void RegisterDisconnectScoFuncFuzzTest() +{ + HfpBluetoothDeviceManager deviceManager; + deviceManager.RegisterDisconnectScoFunc(nullptr); +} + +vector g_testFuncs = { + RegisterDeviceObserverFuzzTest, + SetMediaStackFuzzTest, + SendUserSelectionEventFuzzTest, + NotifyToUpdateAudioDeviceFuzzTest, + IsA2dpBluetoothDeviceConnectingFuzzTest, + UpdateA2dpDeviceConfigurationFuzzTest, + SetA2dpInStackFuzzTest, + A2dpInNotifyToUpdateAudioDeviceFuzzTest, + GetA2dpInDeviceStreamInfoFuzzTest, + GetAllA2dpInBluetoothDeviceFuzzTest, + SetHfpStackFuzzTest, + HfpNotifyToUpdateAudioDeviceFuzzTest, + IsHfpBluetoothDeviceConnectingFuzzTest, + GetConnectedHfpBluetoothDeviceFuzzTest, + GetAllHfpBluetoothDeviceFuzzTest, + OnScoStateChangedFuzzTest, + RegisterDisconnectScoFuncFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} \ No newline at end of file diff --git a/test/fuzztest/bluetoothdevicemanager_fuzzer/project.xml b/test/fuzztest/bluetoothdevicemanager_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec --- /dev/null +++ b/test/fuzztest/bluetoothdevicemanager_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/bluetoothscomanager_fuzzer/BUILD.gn b/test/fuzztest/bluetoothscomanager_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..052acd9d88b798eb444b5bb65fb9a23f407cc233 --- /dev/null +++ b/test/fuzztest/bluetoothscomanager_fuzzer/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("BluetoothScoManagerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../bluetoothscomanager_fuzzer" + + include_dirs = [ + "../../../frameworks/native/bluetoothclient", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ + "bluetooth_sco_manager_fuzzer.cpp", + "../../../frameworks/native/bluetoothclient/bluetooth_device_manager.cpp", + "../../../frameworks/native/bluetoothclient/bluetooth_device_utils.cpp", + "../../../frameworks/native/bluetoothclient/bluetooth_hfp_interface.cpp", + "../../../frameworks/native/bluetoothclient/bluetooth_sco_manager.cpp", + ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../frameworks/native/bluetoothclient:audio_bluetooth_client", + "../../../services/audio_policy:audio_foundation", + "../../../frameworks/native/audioutils:audio_utils", + ] + external_deps = [ + "access_token:libaccesstoken_sdk", + "bluetooth:btframework", + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_single", + "qos_manager:concurrent_task_client", + "safwk:system_ability_fwk", + "hisysevent:libhisysevent", + ] + + defines = [] + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":BluetoothScoManagerFuzzTest" ] +} diff --git a/test/fuzztest/bluetoothscomanager_fuzzer/bluetooth_sco_manager_fuzzer.cpp b/test/fuzztest/bluetoothscomanager_fuzzer/bluetooth_sco_manager_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..de22fab3b1e742bbf5cea33d4e3897434b75f0a0 --- /dev/null +++ b/test/fuzztest/bluetoothscomanager_fuzzer/bluetooth_sco_manager_fuzzer.cpp @@ -0,0 +1,264 @@ +/* + * Copyright (c) 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 + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "bluetooth_device_manager.h" +#include "bluetooth_device_utils.h" +#include "audio_info.h" +#include "audio_engine_log.h" +#include "idevice_status_observer.h" +#include "../fuzz_utils.h" +#include "bluetooth_sco_manager.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; +using namespace Bluetooth; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; +const int32_t TRANSPORT = 2; + +typedef void (*TestFuncs)(); + +void UpdateScoStateWhenDisconnectedFuzzTest() +{ + BluetoothScoManager scoManager; + HfpScoConnectState scoState = HfpScoConnectState::SCO_CONNECTED; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + int reason = g_fuzzUtils.GetData(); + scoManager.UpdateScoStateWhenDisconnected(scoState, device, reason); +} + +void UpdateScoStateWhenConnectedFuzzTest() +{ + BluetoothScoManager scoManager; + HfpScoConnectState scoState = HfpScoConnectState::SCO_DISCONNECTED; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + int reason = g_fuzzUtils.GetData(); + scoManager.UpdateScoStateWhenConnected(scoState, device, reason); +} + +void UpdateScoStateWhenConnectingFuzzTest() +{ + BluetoothScoManager scoManager; + HfpScoConnectState scoState = HfpScoConnectState::SCO_DISCONNECTED; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + int reason = g_fuzzUtils.GetData(); + scoManager.UpdateScoStateWhenConnecting(scoState, device, reason); +} + +void UpdateScoStateWhenDisconnectingFuzzTest() +{ + BluetoothScoManager scoManager; + HfpScoConnectState scoState = HfpScoConnectState::SCO_DISCONNECTED; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + int reason = g_fuzzUtils.GetData(); + scoManager.UpdateScoStateWhenDisconnecting(scoState, device, reason); +} + +void WriteScoStateFaultEventFuzzTest() +{ + BluetoothScoManager scoManager; + HfpScoConnectState scoState = HfpScoConnectState::SCO_DISCONNECTED; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + int reason = g_fuzzUtils.GetData(); + scoManager.WriteScoStateFaultEvent(scoState, device, reason); +} + +void ForceUpdateScoCategoryFuzzTest() +{ + BluetoothScoManager scoManager; + scoManager.ForceUpdateScoCategory(); +} + +void ProcCacheRequestFuzzTest() +{ + BluetoothScoManager scoManager; + scoManager.ProcCacheRequest(); +} + +void HandleScoConnectFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + ScoCategory category = ScoCategory::SCO_DEFAULT; + scoManager.HandleScoConnect(category, device); +} + +void HandleScoConnectNoLockFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + ScoCategory category = ScoCategory::SCO_DEFAULT; + scoManager.HandleScoConnectNoLock(category, device); +} + +void ProcConnectReqWhenDisconnectedFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + ScoCategory category = ScoCategory::SCO_DEFAULT; + scoManager.ProcConnectReqWhenDisconnected(category, device); +} + +void ProcConnectReqWhenConnectedFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + ScoCategory category = ScoCategory::SCO_DEFAULT; + scoManager.ProcConnectReqWhenConnected(category, device); +} + +void ProcConnectReqWhenConnectingFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + ScoCategory category = ScoCategory::SCO_DEFAULT; + scoManager.ProcConnectReqWhenConnecting(category, device); +} + +void IsNeedSwitchScoCategoryFuzzTest() +{ + BluetoothScoManager scoManager; + ScoCategory category = ScoCategory::SCO_DEFAULT; + scoManager.IsNeedSwitchScoCategory(category); +} + +void ProcDisconnectReqWhenConnectedFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + scoManager.ProcDisconnectReqWhenConnected(device); +} + +void ProcDisconnectReqWhenConnectingFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + scoManager.ProcDisconnectReqWhenConnecting(device); +} + +void IsSameHfpDeviceFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device1("00:11:22:33:44:55", TRANSPORT); + BluetoothRemoteDevice device2("00:11:22:33:44:55", TRANSPORT); + scoManager.IsSameHfpDevice(device1, device2); +} + +void ConnectAndDisconnectScoFuzzTest() +{ + BluetoothScoManager scoManager; + ScoCategory category = ScoCategory::SCO_DEFAULT; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + scoManager.ConnectSco(category, device); + scoManager.DisconnectSco(category, device); +} + +void TryRestoreHfpDeviceFuzzTest() +{ + BluetoothScoManager scoManager; + ScoCategory category = ScoCategory::SCO_DEFAULT; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + scoManager.TryRestoreHfpDevice(category, device); +} + +void DisconnectScoReliableFuzzTest() +{ + BluetoothScoManager scoManager; + ScoCategory category = ScoCategory::SCO_DEFAULT; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + scoManager.DisconnectScoReliable(category, device); +} + +void GetAudioScoStateFuzzTest() +{ + BluetoothScoManager scoManager; + scoManager.GetAudioScoState(); +} + +void GetAudioScoCategoryFuzzTest() +{ + BluetoothScoManager scoManager; + scoManager.GetAudioScoCategory(); +} + +void ResetScoStateFuzzTest() +{ + BluetoothScoManager scoManager; + BluetoothRemoteDevice device("00:11:22:33:44:55", TRANSPORT); + scoManager.ResetScoState(device); +} + +void SetAudioScoStateFuzzTest() +{ + BluetoothScoManager scoManager; + AudioScoState state = AudioScoState::CONNECTING; + scoManager.SetAudioScoState(state); +} + +void OnScoStateTimeOutFuzzTest() +{ + BluetoothScoManager scoManager; + scoManager.OnScoStateTimeOut(); +} + +void GetAudioScoDeviceFuzzTest() +{ + BluetoothScoManager scoManager; + scoManager.GetAudioScoDevice(); +} + +vector g_testFuncs = { + UpdateScoStateWhenDisconnectedFuzzTest, + UpdateScoStateWhenConnectedFuzzTest, + UpdateScoStateWhenConnectingFuzzTest, + UpdateScoStateWhenDisconnectingFuzzTest, + WriteScoStateFaultEventFuzzTest, + ForceUpdateScoCategoryFuzzTest, + ProcCacheRequestFuzzTest, + HandleScoConnectFuzzTest, + HandleScoConnectNoLockFuzzTest, + ProcConnectReqWhenDisconnectedFuzzTest, + ProcConnectReqWhenConnectedFuzzTest, + ProcConnectReqWhenConnectingFuzzTest, + IsNeedSwitchScoCategoryFuzzTest, + ProcDisconnectReqWhenConnectedFuzzTest, + ProcDisconnectReqWhenConnectingFuzzTest, + IsSameHfpDeviceFuzzTest, + ConnectAndDisconnectScoFuzzTest, + TryRestoreHfpDeviceFuzzTest, + DisconnectScoReliableFuzzTest, + GetAudioScoStateFuzzTest, + GetAudioScoCategoryFuzzTest, + ResetScoStateFuzzTest, + SetAudioScoStateFuzzTest, + OnScoStateTimeOutFuzzTest, + GetAudioScoDeviceFuzzTest, +}; +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { + return 0; + } + + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/bluetoothscomanager_fuzzer/project.xml b/test/fuzztest/bluetoothscomanager_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..500f6f414493290025d8dea9b066e5d5021a9377 --- /dev/null +++ b/test/fuzztest/bluetoothscomanager_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file diff --git a/test/fuzztest/captureclockmanager_fuzzer/capture_clock_manager_fuzzer.cpp b/test/fuzztest/captureclockmanager_fuzzer/capture_clock_manager_fuzzer.cpp index 9530aebc3aa59beeb6ef4bfcf03955a4a36286fd..b6c9767642f67f3f4241ae80e93e61c644361180 100644 --- a/test/fuzztest/captureclockmanager_fuzzer/capture_clock_manager_fuzzer.cpp +++ b/test/fuzztest/captureclockmanager_fuzzer/capture_clock_manager_fuzzer.cpp @@ -47,7 +47,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 5; static int32_t NUM_2 = 2; constexpr uint64_t MOCK_POSITION_INC = 960; constexpr uint32_t MOCK_SAMPLE_RATE = 48000; @@ -166,7 +165,7 @@ void GetTimeStampByPositionDifferentFuzzTest() CapturerClockManager::GetInstance().DeleteCapturerClock(1); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { GetMediaRenderDeviceFuzzTest, GetRecordCaptureDeviceFuzzTest, CaptureClockStartAndStopFuzzTest, diff --git a/test/fuzztest/capturerinserver_fuzzer/BUILD.gn b/test/fuzztest/capturerinserver_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..dac21caa12e51f563e9ae8e369e6f7ce55434ea2 --- /dev/null +++ b/test/fuzztest/capturerinserver_fuzzer/BUILD.gn @@ -0,0 +1,85 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("CapturerInServerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../capturerinserver_fuzzer" + + include_dirs = [ + "../../../frameworks/native/audioinnercall/include", + "../../../frameworks/native/hdiadapter_new/include", + "../../../services/audio_service/server/include", + "../../../services/audio_service/client/include", + "../../../services/audio_policy/client/include", + "../../../services/audio_service/common/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ "capturer_in_server_fuzzer.cpp" ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../frameworks/native/hdiadapter_new:hdiadapter_new", + "../../../services/audio_policy:audio_policy_client", + "../../../services/audio_service:audio_client", + "../../../services/audio_service:audio_common", + "../../../services/audio_service:audio_process_service_static", + "../../../services/audio_service:audio_service_static", + ] + external_deps = [ + "ability_base:want", + "access_token:libaccesstoken_sdk", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "eventhandler:libeventhandler", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "qos_manager:concurrent_task_client", + ] + + defines = [] + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } +} + +group("fuzztest") { + testonly = true + deps = [] + if (audio_framework_feature_low_latency) { + deps += [ ":CapturerInServerFuzzTest" ] + } +} diff --git a/test/fuzztest/capturerinserver_fuzzer/capturer_in_server_fuzzer.cpp b/test/fuzztest/capturerinserver_fuzzer/capturer_in_server_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8ccafdf77adc3220ec6a85e57a145280746b77d7 --- /dev/null +++ b/test/fuzztest/capturerinserver_fuzzer/capturer_in_server_fuzzer.cpp @@ -0,0 +1,511 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "capturer_in_server.h" +#include "ipc_stream_in_server.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; +const uint32_t APPID_LENGTH = 10; +const int64_t STOP_TIME = 100; +std::shared_ptr capturerInServer_ = nullptr; + +typedef void (*TestFuncs)(); + +vector IOperationVec = { + OPERATION_INVALID, + OPERATION_STARTED, + OPERATION_PAUSED, + OPERATION_STOPPED, + OPERATION_FLUSHED, + OPERATION_DRAINED, + OPERATION_RELEASED, + OPERATION_UNDERRUN, + OPERATION_UNDERFLOW, + OPERATION_SET_OFFLOAD_ENABLE, + OPERATION_UNSET_OFFLOAD_ENABLE, + OPERATION_DATA_LINK_CONNECTING, + OPERATION_DATA_LINK_CONNECTED, +}; + +vector IStatusVec = { + I_STATUS_INVALID, + I_STATUS_IDLE, + I_STATUS_STARTING, + I_STATUS_STARTED, + I_STATUS_PAUSING, + I_STATUS_PAUSED, + I_STATUS_FLUSHING_WHEN_STARTED, + I_STATUS_FLUSHING_WHEN_PAUSED, + I_STATUS_FLUSHING_WHEN_STOPPED, + I_STATUS_DRAINING, + I_STATUS_DRAINED, + I_STATUS_STOPPING, + I_STATUS_STOPPED, + I_STATUS_RELEASING, + I_STATUS_RELEASED, +}; + +vector AudioSampleFormatVec = { + SAMPLE_U8, + SAMPLE_S16LE, + SAMPLE_S24LE, + SAMPLE_S32LE, + SAMPLE_F32LE, + INVALID_WIDTH, +}; + +vector SourceTypeVec = { + SOURCE_TYPE_INVALID, + SOURCE_TYPE_MIC, + SOURCE_TYPE_VOICE_RECOGNITION, + SOURCE_TYPE_PLAYBACK_CAPTURE, + SOURCE_TYPE_WAKEUP, + SOURCE_TYPE_VOICE_CALL, + SOURCE_TYPE_VOICE_COMMUNICATION, + SOURCE_TYPE_ULTRASONIC, + SOURCE_TYPE_VIRTUAL_CAPTURE, + SOURCE_TYPE_VOICE_MESSAGE, + SOURCE_TYPE_REMOTE_CAST, + SOURCE_TYPE_VOICE_TRANSCRIPTION, + SOURCE_TYPE_CAMCORDER, + SOURCE_TYPE_UNPROCESSED, + SOURCE_TYPE_EC, + SOURCE_TYPE_MIC_REF, + SOURCE_TYPE_LIVE, + SOURCE_TYPE_MAX, +}; + +class ICapturerStreamTest : public ICapturerStream { +public: + int32_t GetStreamFramesRead(uint64_t &framesRead) override { return 0; } + int32_t GetCurrentTimeStamp(uint64_t ×tamp) override { return 0; } + int32_t GetLatency(uint64_t &latency) override { return 0; } + void RegisterReadCallback(const std::weak_ptr &callback) override { return; } + int32_t GetMinimumBufferSize(size_t &minBufferSize) const override { return 0; } + void GetByteSizePerFrame(size_t &byteSizePerFrame) const override { return; } + void GetSpanSizePerFrame(size_t &spanSizeInFrame) const override { spanSizeInFrame = 0; } + int32_t DropBuffer() override { return 0; } + void SetStreamIndex(uint32_t index) override { return; } + uint32_t GetStreamIndex() override { return 0; } + int32_t Start() override { return 0; } + int32_t Pause(bool isStandby = false) override { return 0; } + int32_t Flush() override { return 0; } + int32_t Drain(bool stopFlag = false) override { return 0; } + int32_t Stop() override { return 0; } + int32_t Release() override { return 0; } + void RegisterStatusCallback(const std::weak_ptr &callback) override { return; } + BufferDesc DequeueBuffer(size_t length) override + { + BufferDesc bufferDesc; + return bufferDesc; + } + int32_t EnqueueBuffer(const BufferDesc &bufferDesc) override { return 0; } +}; + +class ConcreteIStreamListener : public IStreamListener { + int32_t OnOperationHandled(Operation operation, int64_t result) { return SUCCESS; } +}; + +static AudioProcessConfig GetInnerCapConfig() +{ + AudioProcessConfig config; + config.appInfo.appUid = APPID_LENGTH; + config.appInfo.appPid = APPID_LENGTH; + config.streamInfo.format = SAMPLE_S32LE; + config.streamInfo.samplingRate = SAMPLE_RATE_48000; + config.streamInfo.channels = STEREO; + config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO; + config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK; + config.streamType = AudioStreamType::STREAM_MUSIC; + config.deviceType = DEVICE_TYPE_USB_HEADSET; + return config; +} + +void Init() +{ + AudioProcessConfig config = GetInnerCapConfig(); + std::weak_ptr innerListener = std::weak_ptr(); + capturerInServer_ = std::make_shared(config, innerListener); +} + +void OnStatusUpdateFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + std::shared_ptr streamListenerHolder = + std::make_shared(); + if (streamListenerHolder == nullptr) { + return; + } + capturerInServer_->streamListener_ = std::weak_ptr(); + if (capturerInServer_->streamListener_.lock() == nullptr) { + capturerInServer_->streamListener_ = streamListenerHolder; + } + AppInfo appInfo; + uint32_t index = g_fuzzUtils.GetData(); + capturerInServer_->recorderDfx_ = std::make_unique(appInfo, index); + for (size_t i = 0; i < IOperationVec.size(); i++) { + IOperation operation = IOperationVec[i]; + capturerInServer_->OnStatusUpdate(operation); + } +} + +void HandleOperationFlushedFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + for (size_t i = 0; i < IStatusVec.size(); i++) { + capturerInServer_->status_ = IStatusVec[i]; + capturerInServer_->HandleOperationFlushed(); + } +} + +void DequeueBufferFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + size_t length = g_fuzzUtils.GetData(); + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + capturerInServer_->DequeueBuffer(length); +} + +void IsReadDataOverFlowFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + size_t length = g_fuzzUtils.GetData(); + uint64_t currentWriteFrame = g_fuzzUtils.GetData(); + uint32_t totalSizeInFrame = g_fuzzUtils.GetData(); + uint32_t spanSizeInFrame = g_fuzzUtils.GetData(); + uint32_t byteSizePerFrame = g_fuzzUtils.GetData(); + std::shared_ptr stateListener = std::make_shared(); + if (stateListener == nullptr) { + return; + } + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + capturerInServer_->audioServerBuffer_ = std::make_shared(AudioBufferHolder::AUDIO_CLIENT, + totalSizeInFrame, spanSizeInFrame, byteSizePerFrame); + if (capturerInServer_->audioServerBuffer_ == nullptr) { + return; + } + auto bufferInfo = std::make_shared(); + if (bufferInfo == nullptr) { + return; + } + capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = bufferInfo.get(); + if (capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ == nullptr) { + return; + } + capturerInServer_->IsReadDataOverFlow(length, currentWriteFrame, stateListener); +} + +void UpdateBufferTimeStampFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + uint32_t capturerSampleRate = g_fuzzUtils.GetData(); + size_t readLen = g_fuzzUtils.GetData(); + capturerInServer_->capturerClock_ = std::make_shared(capturerSampleRate); + if (capturerInServer_->capturerClock_ == nullptr) { + return; + } + uint32_t totalSizeInFrame = g_fuzzUtils.GetData(); + uint32_t spanSizeInFrame = g_fuzzUtils.GetData(); + uint32_t byteSizePerFrame = g_fuzzUtils.GetData(); + capturerInServer_->audioServerBuffer_ = std::make_shared(AudioBufferHolder::AUDIO_CLIENT, + totalSizeInFrame, spanSizeInFrame, byteSizePerFrame); + if (capturerInServer_->audioServerBuffer_ == nullptr) { + return; + } + capturerInServer_->processConfig_ = GetInnerCapConfig(); + for (size_t i = 0; i < AudioSampleFormatVec.size(); i++) { + capturerInServer_->processConfig_.streamInfo.format = AudioSampleFormatVec[i]; + capturerInServer_->UpdateBufferTimeStamp(readLen); + } +} + +void ReadDataFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + size_t cacheSize = g_fuzzUtils.GetData(); + capturerInServer_->ringCache_ = AudioRingCache::Create(cacheSize); + if (capturerInServer_->ringCache_ == nullptr) { + return; + } + size_t length = g_fuzzUtils.GetData(); + capturerInServer_->ReadData(length); +} + +void OnReadDataFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + size_t length = g_fuzzUtils.GetData(); + capturerInServer_->OnReadData(length); + int8_t outputData = g_fuzzUtils.GetData(); + size_t requestDataLen = g_fuzzUtils.GetData(); + capturerInServer_->OnReadData(&outputData, requestDataLen); +} + +void StopSessionFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + capturerInServer_->StopSession(); +} + +void GetLastAudioDurationFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + capturerInServer_->lastStopTime_ = STOP_TIME; + capturerInServer_->lastStartTime_ = 0; + capturerInServer_->GetLastAudioDuration(); +} + +void RestoreSessionFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + RestoreInfo restoreInfo; + uint32_t totalSizeInFrame = g_fuzzUtils.GetData(); + uint32_t spanSizeInFrame = g_fuzzUtils.GetData(); + uint32_t byteSizePerFrame = g_fuzzUtils.GetData(); + capturerInServer_->audioServerBuffer_ = std::make_shared(AudioBufferHolder::AUDIO_CLIENT, + totalSizeInFrame, spanSizeInFrame, byteSizePerFrame); + if (capturerInServer_->audioServerBuffer_ == nullptr) { + return; + } + capturerInServer_->RestoreSession(restoreInfo); +} + +void GetLatencyFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + uint64_t latency = g_fuzzUtils.GetData(); + capturerInServer_->GetLatency(latency); +} + +void GetAudioTimeFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + uint64_t framePos = g_fuzzUtils.GetData(); + uint64_t timestamp = g_fuzzUtils.GetData(); + uint32_t index = g_fuzzUtils.GetData() % IStatusVec.size(); + capturerInServer_->status_ = IStatusVec[index]; + capturerInServer_->resetTime_ = g_fuzzUtils.GetData(); + capturerInServer_->GetAudioTime(framePos, timestamp); +} + +void UpdatePlaybackCaptureConfigFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + #ifdef HAS_FEATURE_INNERCAPTURER + AudioPlaybackCaptureConfig config; + uint32_t sourceTypeCount = g_fuzzUtils.GetData() % SourceTypeVec.size(); + capturerInServer_->processConfig_.capturerInfo.sourceType = SourceTypeVec[sourceTypeCount]; + capturerInServer_->UpdatePlaybackCaptureConfig(config); + #endif +} + +void UpdatePlaybackCaptureConfigInLegacyFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + #ifdef HAS_FEATURE_INNERCAPTURER + AudioPlaybackCaptureConfig config; + capturerInServer_->UpdatePlaybackCaptureConfigInLegacy(config); + #endif +} + +void PauseFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + capturerInServer_->status_ = I_STATUS_STARTED; + capturerInServer_->needCheckBackground_ = g_fuzzUtils.GetData(); + capturerInServer_->streamIndex_ = g_fuzzUtils.GetData(); + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + capturerInServer_->Pause(); +} + +void FlushFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + uint32_t index = g_fuzzUtils.GetData() % IStatusVec.size(); + capturerInServer_->status_ = IStatusVec[index]; + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + uint32_t totalSizeInFrame = g_fuzzUtils.GetData(); + uint32_t spanSizeInFrame = g_fuzzUtils.GetData(); + uint32_t byteSizePerFrame = g_fuzzUtils.GetData(); + capturerInServer_->audioServerBuffer_ = std::make_shared(AudioBufferHolder::AUDIO_CLIENT, + totalSizeInFrame, spanSizeInFrame, byteSizePerFrame); + if (capturerInServer_->audioServerBuffer_ == nullptr) { + return; + } + capturerInServer_->Flush(); +} + +void StopFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + uint32_t index = g_fuzzUtils.GetData() % IStatusVec.size(); + capturerInServer_->status_ = IStatusVec[index]; + capturerInServer_->stream_ = std::make_shared(); + if (capturerInServer_->stream_ == nullptr) { + return; + } + uint32_t capturerSampleRate = g_fuzzUtils.GetData(); + capturerInServer_->capturerClock_ = std::make_shared(capturerSampleRate); + if (capturerInServer_->capturerClock_ == nullptr) { + return; + } + capturerInServer_->needCheckBackground_ = g_fuzzUtils.GetData(); + capturerInServer_->Stop(); +} + +void ReleaseFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + uint32_t index = g_fuzzUtils.GetData() % IStatusVec.size(); + capturerInServer_->status_ = IStatusVec[index]; + capturerInServer_->needCheckBackground_ = g_fuzzUtils.GetData(); + capturerInServer_->processConfig_.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE; + capturerInServer_->Release(); +} + +void InitCacheBufferFuzzTest() +{ + Init(); + if (capturerInServer_ == nullptr) { + return; + } + size_t targetSize = g_fuzzUtils.GetData(); + size_t cacheSize = g_fuzzUtils.GetData(); + capturerInServer_->ringCache_ = AudioRingCache::Create(cacheSize); + if (capturerInServer_->ringCache_ == nullptr) { + return; + } + capturerInServer_->spanSizeInBytes_ = 0; + capturerInServer_->InitCacheBuffer(targetSize); +} + +vector g_testFuncs = { + OnStatusUpdateFuzzTest, + HandleOperationFlushedFuzzTest, + DequeueBufferFuzzTest, + IsReadDataOverFlowFuzzTest, + UpdateBufferTimeStampFuzzTest, + ReadDataFuzzTest, + OnReadDataFuzzTest, + StopSessionFuzzTest, + GetLastAudioDurationFuzzTest, + RestoreSessionFuzzTest, + GetLatencyFuzzTest, + GetAudioTimeFuzzTest, + UpdatePlaybackCaptureConfigFuzzTest, + UpdatePlaybackCaptureConfigInLegacyFuzzTest, + PauseFuzzTest, + FlushFuzzTest, + StopFuzzTest, + ReleaseFuzzTest, + InitCacheBufferFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { + return 0; + } + + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/capturerinserver_fuzzer/corpus/init b/test/fuzztest/capturerinserver_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/capturerinserver_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/capturerinserver_fuzzer/project.xml b/test/fuzztest/capturerinserver_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/capturerinserver_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/coreserviceproviderstub_fuzzer/core_service_provider_stub_fuzzer.cpp b/test/fuzztest/coreserviceproviderstub_fuzzer/core_service_provider_stub_fuzzer.cpp index 26ebf9ff304ec26082cf2ca715ee0786f6064a73..8861e3dcdb2b813a5054283647057697c5c69d71 100644 --- a/test/fuzztest/coreserviceproviderstub_fuzzer/core_service_provider_stub_fuzzer.cpp +++ b/test/fuzztest/coreserviceproviderstub_fuzzer/core_service_provider_stub_fuzzer.cpp @@ -32,7 +32,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 7; typedef void (*TestFuncs)(); @@ -136,7 +135,26 @@ void GenerateSessionIdFuzzTest() coreServiceProviderWrapper.GenerateSessionId(sessionId); } -TestFuncs g_testFuncs[TESTSIZE] = { +void GetMuteStateFuzzTest() +{ + std::shared_ptr audioCoreService = AudioCoreService::GetCoreService(); + auto coreServiceWorker = new AudioCoreService::EventEntry(audioCoreService); + CoreServiceProviderWrapper coreServiceProviderWrapper(static_cast(coreServiceWorker)); + uint32_t sessionId = GetData(); + bool muteState = GetData(); + coreServiceProviderWrapper.GetVoiceMuteState(sessionId, muteState); +} + +void RemoveMuteStateFuzzTest() +{ + std::shared_ptr audioCoreService = AudioCoreService::GetCoreService(); + auto coreServiceWorker = new AudioCoreService::EventEntry(audioCoreService); + CoreServiceProviderWrapper coreServiceProviderWrapper(static_cast(coreServiceWorker)); + uint32_t sessionId = GetData(); + coreServiceProviderWrapper.RemoveVoiceMuteState(sessionId); +} + +TestFuncs g_testFuncs[] = { CoreServiceProviderWrapperFuzzTest, UpdateSessionOperationFuzzTest, ReloadCaptureSessionFuzzTest, @@ -144,6 +162,8 @@ TestFuncs g_testFuncs[TESTSIZE] = { GetAdapterNameBySessionIdFuzzTest, GetProcessDeviceInfoBySessionIdFuzzTest, GenerateSessionIdFuzzTest, + GetMuteStateFuzzTest, + RemoveMuteStateFuzzTest, }; diff --git a/test/fuzztest/deviceinitcallback_fuzzer/BUILD.gn b/test/fuzztest/deviceinitcallback_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..698dd1f6895f8a3fc8853f694b4eccc5471f17b2 --- /dev/null +++ b/test/fuzztest/deviceinitcallback_fuzzer/BUILD.gn @@ -0,0 +1,77 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../accessibility.gni") +import("../../../config.gni") +import("../../../bluetooth_part.gni") + +ohos_fuzztest("DeviceInitCallbackFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../deviceinitcallback_fuzzer" + + include_dirs = [ + "../../../services/audio_policy/server/service/service_main/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + configs = [] + + sources = [ "device_init_callback_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_policy:audio_policy_service_static", + ] + + external_deps = [ + "ability_runtime:wantagent_innerkits", + "background_task_mgr:bgtaskmgr_innerkits", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "data_share:datashare_consumer", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hilog:libhilog", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "samgr:samgr_proxy", + ] + + defines = [] + if (audio_framework_feature_device_manager) { + defines += [ "FEATURE_DEVICE_MANAGER" ] + external_deps += [ "device_manager:devicemanagersdk" ] + } + if (bluetooth_part_enable == true) { + deps += + [ "../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":DeviceInitCallbackFuzzTest" ] +} diff --git a/test/fuzztest/deviceinitcallback_fuzzer/corpus/init b/test/fuzztest/deviceinitcallback_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/deviceinitcallback_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/deviceinitcallback_fuzzer/device_init_callback_fuzzer.cpp b/test/fuzztest/deviceinitcallback_fuzzer/device_init_callback_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f8238c652d84afef30667423ab8ef3c65008dc13 --- /dev/null +++ b/test/fuzztest/deviceinitcallback_fuzzer/device_init_callback_fuzzer.cpp @@ -0,0 +1,63 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "device_init_callback.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const int32_t TEST_DEVICE_NAME_LENGTH = 4; + +typedef void (*TestFuncs)(); + +void DeviceStatusCallbackImplOnDeviceChangedFuzzTest() +{ + shared_ptr deviceStatusCallbackImpl = make_shared(); + CHECK_AND_RETURN(deviceStatusCallbackImpl != nullptr); + DistributedHardware::DmDeviceBasicInfo dmDeviceBasicInfo; + strncpy_s(dmDeviceBasicInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, + "test", TEST_DEVICE_NAME_LENGTH); + deviceStatusCallbackImpl->OnDeviceChanged(dmDeviceBasicInfo); +} + +void DeviceStatusCallbackImplOnDeviceOfflineFuzzTest() +{ + shared_ptr deviceStatusCallbackImpl = make_shared(); + CHECK_AND_RETURN(deviceStatusCallbackImpl != nullptr); + DistributedHardware::DmDeviceInfo dmDeviceInfo; + strncpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, + "test", TEST_DEVICE_NAME_LENGTH); + deviceStatusCallbackImpl->OnDeviceOffline(dmDeviceInfo); +} + +vector g_testFuncs = { + DeviceStatusCallbackImplOnDeviceChangedFuzzTest, + DeviceStatusCallbackImplOnDeviceOfflineFuzzTest, +}; +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/deviceinitcallback_fuzzer/project.xml b/test/fuzztest/deviceinitcallback_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/deviceinitcallback_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/dfxmsgmanager_fuzzer/dfx_msg_manager_fuzzer.cpp b/test/fuzztest/dfxmsgmanager_fuzzer/dfx_msg_manager_fuzzer.cpp index 70fbdda2597db6aba38f0b8de3f80b9a2fb9572e..5aa2db51a427abe307825a71c7e280b2d26ebecd 100644 --- a/test/fuzztest/dfxmsgmanager_fuzzer/dfx_msg_manager_fuzzer.cpp +++ b/test/fuzztest/dfxmsgmanager_fuzzer/dfx_msg_manager_fuzzer.cpp @@ -43,7 +43,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 15; const int32_t COUNT = 100; const int32_t NUM_2 = 2; diff --git a/test/fuzztest/formatconverter_fuzzer/format_converter_fuzzer.cpp b/test/fuzztest/formatconverter_fuzzer/format_converter_fuzzer.cpp index abe2a44c10e923fd5d4099df1fa3c51dc0e1ce09..362957e2dd614e65eccebe3a49857557461e50be 100644 --- a/test/fuzztest/formatconverter_fuzzer/format_converter_fuzzer.cpp +++ b/test/fuzztest/formatconverter_fuzzer/format_converter_fuzzer.cpp @@ -44,63 +44,31 @@ #include "audio_effect_volume.h" #include "futex_tool.h" #include "format_converter.h" +#include "../fuzz_utils.h" namespace OHOS { namespace AudioStandard { using namespace std; -static const uint8_t* RAW_DATA = nullptr; -static size_t g_dataSize = 0; -static size_t g_pos; -const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 6; -static int32_t NUM_2 = 2; -const int32_t NUM_4 = 2; -const int32_t NUM_8 = 2; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const int32_t BUFFER_SIZE_SMALL = 2; +const int32_t BUFFER_SIZE_MEDIUM = 4; +const int32_t BUFFER_SIZE_LARGE = 8; typedef void (*TestFuncs)(); -template -T GetData() -{ - T object {}; - size_t objectSize = sizeof(object); - if (g_dataSize < g_pos) { - return object; - } - if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) { - return object; - } - errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize); - if (ret != EOK) { - return {}; - } - g_pos += objectSize; - return object; -} - -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); -} - void S16StereoToF32StereoFuzzTest() { BufferDesc srcDesc; BufferDesc dstDesc; - uint8_t srcBuffer[NUM_4] = {0}; - uint8_t dstBuffer[NUM_8] = {0}; - srcDesc.bufLength = NUM_4; + uint8_t srcBuffer[BUFFER_SIZE_MEDIUM] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_LARGE] = {0}; + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; srcDesc.buffer = srcBuffer; - dstDesc.bufLength = NUM_2; + dstDesc.bufLength = BUFFER_SIZE_SMALL; dstDesc.buffer = dstBuffer; FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc); - dstDesc.bufLength = NUM_8; + dstDesc.bufLength = BUFFER_SIZE_LARGE; FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc); } @@ -108,14 +76,14 @@ void S16StereoToF32MonoFuzzTest() { BufferDesc srcDesc; BufferDesc dstDesc; - uint8_t srcBuffer[NUM_4] = {0}; - uint8_t dstBuffer[NUM_4] = {0}; - srcDesc.bufLength = NUM_4; + uint8_t srcBuffer[BUFFER_SIZE_MEDIUM] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_MEDIUM] = {0}; + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; srcDesc.buffer = srcBuffer; - dstDesc.bufLength = NUM_2; + dstDesc.bufLength = BUFFER_SIZE_SMALL; dstDesc.buffer = dstBuffer; FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); - dstDesc.bufLength = NUM_4; + dstDesc.bufLength = BUFFER_SIZE_MEDIUM; FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); } @@ -123,14 +91,14 @@ void F32MonoToS16StereoFuzzTest() { BufferDesc srcDesc; BufferDesc dstDesc; - uint8_t srcBuffer[NUM_4] = {0}; - uint8_t dstBuffer[NUM_4] = {0}; - srcDesc.bufLength = NUM_4; + uint8_t srcBuffer[BUFFER_SIZE_MEDIUM] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_MEDIUM] = {0}; + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; srcDesc.buffer = srcBuffer; - dstDesc.bufLength = NUM_2; + dstDesc.bufLength = BUFFER_SIZE_SMALL; dstDesc.buffer = dstBuffer; FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - dstDesc.bufLength = NUM_4; + dstDesc.bufLength = BUFFER_SIZE_MEDIUM; FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); } @@ -138,14 +106,14 @@ void F32StereoToS16StereoFuzzTest() { BufferDesc srcDesc; BufferDesc dstDesc; - uint8_t srcBuffer[NUM_8] = {0}; - uint8_t dstBuffer[NUM_4] = {0}; - srcDesc.bufLength = NUM_8; + uint8_t srcBuffer[BUFFER_SIZE_LARGE] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_MEDIUM] = {0}; + srcDesc.bufLength = BUFFER_SIZE_LARGE; srcDesc.buffer = srcBuffer; - dstDesc.bufLength = NUM_2; + dstDesc.bufLength = BUFFER_SIZE_SMALL; dstDesc.buffer = dstBuffer; FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - dstDesc.bufLength = NUM_4; + dstDesc.bufLength = BUFFER_SIZE_MEDIUM; FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); } @@ -153,73 +121,139 @@ void S16MonoToS16StereoFuzzTest() { BufferDesc srcDesc; BufferDesc dstDesc; - uint8_t srcBuffer[NUM_8] = {0}; - uint8_t dstBuffer[NUM_4] = {0}; - srcDesc.bufLength = NUM_2; + uint8_t srcBuffer[BUFFER_SIZE_LARGE] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_MEDIUM] = {0}; + srcDesc.bufLength = BUFFER_SIZE_SMALL; srcDesc.buffer = srcBuffer; - dstDesc.bufLength = NUM_8; + dstDesc.bufLength = BUFFER_SIZE_LARGE; dstDesc.buffer = dstBuffer; FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc); - srcDesc.bufLength = NUM_4; + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc); } void DataAccumulationFromVolumeFuzzTest() { - uint8_t srcBuffer[NUM_8] = {0}; - BufferDesc srcDesc = {srcBuffer, NUM_8, NUM_8}; + uint8_t srcBuffer[BUFFER_SIZE_LARGE] = {0}; + BufferDesc srcDesc = {srcBuffer, BUFFER_SIZE_LARGE, BUFFER_SIZE_LARGE}; AudioStreamData srcData; srcData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO}; srcData.bufferDesc = srcDesc; std::vector srcDataList = {srcData}; - uint8_t dstBuffer[NUM_8] = {0}; - BufferDesc dstDesc = {dstBuffer, NUM_8, NUM_8}; + uint8_t dstBuffer[BUFFER_SIZE_LARGE] = {0}; + BufferDesc dstDesc = {dstBuffer, BUFFER_SIZE_LARGE, BUFFER_SIZE_LARGE}; AudioStreamData dstData; dstData.streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S32LE, STEREO}; dstData.bufferDesc = dstDesc; + dstData.streamInfo.format = g_fuzzUtils.GetData(); FormatConverter::DataAccumulationFromVolume(srcDataList, dstData); } -TestFuncs g_testFuncs[TESTSIZE] = { +void FormatConverterS32MonoToS16StereoFuzzTest() +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + uint8_t srcBuffer[BUFFER_SIZE_LARGE] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_LARGE] = {0}; + + srcDesc.bufLength = BUFFER_SIZE_LARGE; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = BUFFER_SIZE_LARGE; + dstDesc.buffer = dstBuffer; + FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc); +} + +void FormatConverterS32StereoToS16StereoFuzzTest() +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + uint8_t srcBuffer[BUFFER_SIZE_LARGE] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_MEDIUM] = {0}; + + srcDesc.bufLength = BUFFER_SIZE_LARGE; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = BUFFER_SIZE_MEDIUM; + dstDesc.buffer = dstBuffer; + FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); +} + +void FormatConverterS16StereoToS32StereoFuzzTest() +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + uint8_t srcBuffer[BUFFER_SIZE_MEDIUM] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_LARGE] = {0}; + + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = BUFFER_SIZE_LARGE; + dstDesc.buffer = dstBuffer; + FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc); +} + +void FormatConverterS16MonoToS32StereoFuzzTest() +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + uint8_t srcBuffer[BUFFER_SIZE_SMALL] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_LARGE] = {0}; + + srcDesc.bufLength = BUFFER_SIZE_SMALL; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = BUFFER_SIZE_LARGE; + dstDesc.buffer = dstBuffer; + FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); +} + +void FormatConverterS32MonoToS32StereoFuzzTest() +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + uint8_t srcBuffer[BUFFER_SIZE_MEDIUM] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_LARGE] = {0}; + + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = BUFFER_SIZE_LARGE; + dstDesc.buffer = dstBuffer; + FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc); + FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc); +} + +void FormatConverterF32StereoToS32StereoFuzzTest() +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + uint8_t srcBuffer[BUFFER_SIZE_MEDIUM] = {0}; + uint8_t dstBuffer[BUFFER_SIZE_MEDIUM] = {0}; + + srcDesc.bufLength = BUFFER_SIZE_MEDIUM; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = BUFFER_SIZE_MEDIUM; + dstDesc.buffer = dstBuffer; + FormatConverter::F32StereoToS32Stereo(srcDesc, dstDesc); +} + +vector g_testFuncs = { S16StereoToF32StereoFuzzTest, S16StereoToF32MonoFuzzTest, F32MonoToS16StereoFuzzTest, F32StereoToS16StereoFuzzTest, S16MonoToS16StereoFuzzTest, DataAccumulationFromVolumeFuzzTest, + FormatConverterS32MonoToS16StereoFuzzTest, + FormatConverterS32StereoToS16StereoFuzzTest, + FormatConverterS16StereoToS32StereoFuzzTest, + FormatConverterS16MonoToS32StereoFuzzTest, + FormatConverterS32MonoToS32StereoFuzzTest, + FormatConverterF32StereoToS32StereoFuzzTest, }; - -void FuzzTest(const uint8_t* rawData, size_t size) -{ - if (rawData == nullptr) { - return; - } - - // initialize data - RAW_DATA = rawData; - g_dataSize = size; - g_pos = 0; - - uint32_t code = GetData(); - uint32_t len = GetArrLength(g_testFuncs); - if (len > 0) { - g_testFuncs[code % len](); - } else { - AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__); - } - - return; -} } // namespace AudioStandard } // namesapce OHOS /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - if (size < OHOS::AudioStandard::THRESHOLD) { - return 0; - } - - OHOS::AudioStandard::FuzzTest(data, size); + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); return 0; } diff --git a/test/fuzztest/futextool_fuzzer/futex_tool_fuzzer.cpp b/test/fuzztest/futextool_fuzzer/futex_tool_fuzzer.cpp index 03b99658a95b5287191dbe46467a50ceac09c508..d58b32a00124fd7b98bfa15f40f3516797deaf28 100644 --- a/test/fuzztest/futextool_fuzzer/futex_tool_fuzzer.cpp +++ b/test/fuzztest/futextool_fuzzer/futex_tool_fuzzer.cpp @@ -53,7 +53,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 2; static int32_t NUM_2 = 2; static constexpr int64_t TIMEOUT_IN_NS = 300000000; static constexpr uint32_t CYCLES_TIMES = 500; @@ -122,7 +121,7 @@ void FutexWaitFuzzTest() threadWrite.join(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { FutexWakeFuzzTest, FutexWaitFuzzTest, }; diff --git a/test/fuzztest/fuzz_utils.h b/test/fuzztest/fuzz_utils.h index 6b69a9b40f1efa8e7ff74c06a86d0641be4388a1..e9d1efa876e0b7043ffb382258de30c8473125fb 100644 --- a/test/fuzztest/fuzz_utils.h +++ b/test/fuzztest/fuzz_utils.h @@ -16,12 +16,14 @@ #define FUZZ_UTILS_H #include +#include #include -#include "audio_log.h" +#include "audio_common_log.h" namespace OHOS { namespace AudioStandard { +const size_t FUZZ_INPUT_THRESHOLD_SIZE = 10; typedef void (*TestFuncs)(); class FuzzUtils { public: @@ -33,7 +35,7 @@ public: void fuzzTest(const uint8_t *rawData, size_t size, std::vector &testFunctions) { - if (rawData == nullptr) { + if (rawData == nullptr || size < FUZZ_INPUT_THRESHOLD_SIZE) { return; } diff --git a/test/fuzztest/hpaecaptureeffectnode_fuzzer/hpaecaptureeffectnode_fuzzer.cpp b/test/fuzztest/hpaecaptureeffectnode_fuzzer/hpaecaptureeffectnode_fuzzer.cpp index d51954b17f2c66939a5f3386e52d6a044cd2bb92..fa0eb9b0fb57fe49e8bb14649dda241f1edbdee3 100644 --- a/test/fuzztest/hpaecaptureeffectnode_fuzzer/hpaecaptureeffectnode_fuzzer.cpp +++ b/test/fuzztest/hpaecaptureeffectnode_fuzzer/hpaecaptureeffectnode_fuzzer.cpp @@ -45,7 +45,6 @@ static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm" const char* DEFAULT_TEST_DEVICE_CLASS = "file_io"; const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice"; constexpr size_t THRESHOLD = 10; -constexpr uint8_t TESTSIZE = 2; const uint32_t DEFAULT_FRAME_LENGTH = 960; const uint32_t DEFAULT_NODE_ID = 1243; @@ -115,7 +114,7 @@ void CaptureEffectFuzzTest() } typedef void (*TestFuncs)(); -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { ConnectWithInfoFuzzTest, CaptureEffectFuzzTest, }; diff --git a/test/fuzztest/hpaecapturermanager_fuzzer/hpaecapturermanager_fuzzer.cpp b/test/fuzztest/hpaecapturermanager_fuzzer/hpaecapturermanager_fuzzer.cpp index 815e39179a6d391a007d3ad9919dcafbb080fda2..b26bf9581bebd3d76b27b29d0af028af38bd8cc2 100644 --- a/test/fuzztest/hpaecapturermanager_fuzzer/hpaecapturermanager_fuzzer.cpp +++ b/test/fuzztest/hpaecapturermanager_fuzzer/hpaecapturermanager_fuzzer.cpp @@ -33,7 +33,6 @@ using namespace OHOS::AudioStandard::HPAE; namespace OHOS { namespace AudioStandard { using namespace std; -const uint8_t TESTSIZE = 32; static const uint8_t *RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; diff --git a/test/fuzztest/hpaedownmixer_fuzzer/hpae_down_mixer_fuzzer.cpp b/test/fuzztest/hpaedownmixer_fuzzer/hpae_down_mixer_fuzzer.cpp index be106ca4466ae95091673bbaaec658abc63438cf..94ac54364f466437f3a22a549972d52ccee76242 100644 --- a/test/fuzztest/hpaedownmixer_fuzzer/hpae_down_mixer_fuzzer.cpp +++ b/test/fuzztest/hpaedownmixer_fuzzer/hpae_down_mixer_fuzzer.cpp @@ -39,7 +39,6 @@ static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm" const char* DEFAULT_TEST_DEVICE_CLASS = "file_io"; const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice"; constexpr size_t THRESHOLD = 10; -constexpr uint8_t TESTSIZE = 4; // need full audio channel layouts to cover all cases during setting up downmix table -- first part constexpr static AudioChannelLayout FIRST_PART_CH_LAYOUTS = static_cast ( @@ -274,7 +273,7 @@ void ProcesFuzzTest2() } typedef void (*TestFuncs)(); -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { SetParamFuzzTest, SetDefaultChannelLayoutFuzzTest, ProcesFuzzTest1, diff --git a/test/fuzztest/hpaemanager_fuzzer/hpae_manager_fuzzer.cpp b/test/fuzztest/hpaemanager_fuzzer/hpae_manager_fuzzer.cpp index 74111e65888b8fd3f08d3d42ce76026e05600cbe..e75f78ce6e1106dd8a14f370f34bd049ac12d227 100644 --- a/test/fuzztest/hpaemanager_fuzzer/hpae_manager_fuzzer.cpp +++ b/test/fuzztest/hpaemanager_fuzzer/hpae_manager_fuzzer.cpp @@ -38,7 +38,6 @@ static size_t g_pos; static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm"; const uint32_t DEFAULT_FRAME_LENGTH = 960; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 1; typedef void (*TestFuncs)(); @@ -100,7 +99,7 @@ void UploadDumpSourceInfoFuzzTest() capturerManager->UploadDumpSourceInfo(deviceName); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { UploadDumpSourceInfoFuzzTest, }; diff --git a/test/fuzztest/hpaemanagercontrol_fuzzer/hpae_manager_control_fuzzer.cpp b/test/fuzztest/hpaemanagercontrol_fuzzer/hpae_manager_control_fuzzer.cpp index 50b03569a17c3fc99f9662d63a93e1d65d65f8c6..2578df6f0276c5b31e19581131051dafd1f17d05 100644 --- a/test/fuzztest/hpaemanagercontrol_fuzzer/hpae_manager_control_fuzzer.cpp +++ b/test/fuzztest/hpaemanagercontrol_fuzzer/hpae_manager_control_fuzzer.cpp @@ -35,7 +35,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 9; static int32_t NUM_2 = 2; static std::string g_rootPath = "/data/"; constexpr int32_t TEST_SLEEP_TIME_20 = 20; @@ -530,7 +529,7 @@ void GetAllSinksFuzzTest2() WaitForMsgProcessing(hpaeManager_); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { HpaeRenderManagerReloadTest, HpaeRenderManagerReloadTest2, HpaeManagerGetSinkAndSourceInfoTest, diff --git a/test/fuzztest/hpaemanagerstream_fuzzer/hpae_manager_stream_fuzzer.cpp b/test/fuzztest/hpaemanagerstream_fuzzer/hpae_manager_stream_fuzzer.cpp index 3d82e144f4fb7adca1364b418979dcd3c8a92a4a..6a45ee448a1d16f4c16ee83de4ec95e6e8c9def1 100644 --- a/test/fuzztest/hpaemanagerstream_fuzzer/hpae_manager_stream_fuzzer.cpp +++ b/test/fuzztest/hpaemanagerstream_fuzzer/hpae_manager_stream_fuzzer.cpp @@ -35,7 +35,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 14; static int32_t NUM_2 = 2; static std::string g_rootPath = "/data/"; constexpr int32_t TEST_SLEEP_TIME_20 = 20; @@ -721,7 +720,7 @@ void HpaeManagerDumpStreamInfoTest2() WaitForMsgProcessing(hpaeManager_); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { InitFuzzTest, HpaeRenderStreamManagerFuzzTest, HpaeRenderStreamManagerFuzzTest2, diff --git a/test/fuzztest/hpaenolockqueue_fuzzer/hpae_no_lock_queue_fuzzer.cpp b/test/fuzztest/hpaenolockqueue_fuzzer/hpae_no_lock_queue_fuzzer.cpp index 7a9209f29a6ec1ffc5bacd964c98ddc3e87fafb6..70fff38c3917bad747c1edcdb3e642e28a0ec7b3 100644 --- a/test/fuzztest/hpaenolockqueue_fuzzer/hpae_no_lock_queue_fuzzer.cpp +++ b/test/fuzztest/hpaenolockqueue_fuzzer/hpae_no_lock_queue_fuzzer.cpp @@ -48,7 +48,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 6; const size_t TESTQUEUESIZE = 5; static constexpr size_t TESTQUEUESIZETHREE = 3; static int32_t NUM_2 = 2; @@ -136,7 +135,7 @@ void PushRequestNodeFuzzTest() queue_->PushRequestNode(nullptr, index); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { RequestNodeFuzzTest, HpaeNoLockQueueFuzzTest, PushRequestFuzzTest, diff --git a/test/fuzztest/hpaeoffloadrenderermanager_fuzzer/hpaeoffloadrenderermanager_fuzzer.cpp b/test/fuzztest/hpaeoffloadrenderermanager_fuzzer/hpaeoffloadrenderermanager_fuzzer.cpp index 84ecd8c527a121b181034a20bb7e94851c255570..c8e131d473bd2add4c1ca76f0bf8a7292a72f2fe 100644 --- a/test/fuzztest/hpaeoffloadrenderermanager_fuzzer/hpaeoffloadrenderermanager_fuzzer.cpp +++ b/test/fuzztest/hpaeoffloadrenderermanager_fuzzer/hpaeoffloadrenderermanager_fuzzer.cpp @@ -53,7 +53,6 @@ static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm" const char* DEFAULT_TEST_DEVICE_CLASS = "offload"; const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice"; constexpr size_t THRESHOLD = 10; -constexpr uint8_t TESTSIZE = 42; constexpr int32_t TEST_SLEEP_TIME_20 = 20; constexpr int32_t TEST_SLEEP_TIME_40 = 40; constexpr int32_t FRAME_LENGTH_960 = 960; @@ -754,7 +753,7 @@ void UpdateCollaborativeStateFuzzTest() } typedef void (*TestFuncs)(); -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { CreateRendererManagerFuzzTest, UploadDumpSinkInfoFuzzTest, OnNotifyDfxNodeInfoFuzzTest, diff --git a/test/fuzztest/hpaepolicymanager_fuzzer/hpae_policy_manager_fuzzer.cpp b/test/fuzztest/hpaepolicymanager_fuzzer/hpae_policy_manager_fuzzer.cpp index 5e249cae2cf48612ece8ab5b9d301b74534e6e58..7cd909ba212da31a2103e94a744a740ed0372174 100644 --- a/test/fuzztest/hpaepolicymanager_fuzzer/hpae_policy_manager_fuzzer.cpp +++ b/test/fuzztest/hpaepolicymanager_fuzzer/hpae_policy_manager_fuzzer.cpp @@ -47,7 +47,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 22; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -298,7 +297,7 @@ void SetAudioParameterFuzzTest() hpaePolicyManager.GetInstance().SetAudioParameter(adapterName, key, condition, value); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { UpdateSpatializationStateFuzzTest, UpdateSpatialDeviceTypeFuzzTest, SetSpatializationSceneTypeFuzzTest, diff --git a/test/fuzztest/hpaerenderermanageradd_fuzzer/hpaerenderermanager_add_fuzzer.cpp b/test/fuzztest/hpaerenderermanageradd_fuzzer/hpaerenderermanager_add_fuzzer.cpp index 6b57be7068095047fde8a3627e24e113ab54b048..df0f7060bb3748199c834c467d3ca407fe348796 100644 --- a/test/fuzztest/hpaerenderermanageradd_fuzzer/hpaerenderermanager_add_fuzzer.cpp +++ b/test/fuzztest/hpaerenderermanageradd_fuzzer/hpaerenderermanager_add_fuzzer.cpp @@ -53,7 +53,6 @@ static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm" const char* DEFAULT_TEST_DEVICE_CLASS = "file_io"; const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice"; constexpr size_t THRESHOLD = 10; -constexpr uint8_t TESTSIZE = 22; constexpr int32_t TEST_SLEEP_TIME_20 = 20; constexpr int32_t TEST_SLEEP_TIME_40 = 40; constexpr int32_t FRAME_LENGTH_960 = 960; @@ -438,7 +437,7 @@ void HpaeRendererManagerStartWithSyncIdFuzzTest() } typedef void (*TestFuncs)(); -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { HpaeRendererManagerSetPrivacyTypeFuzzTest, HpaeRendererManagerGetPrivacyTypeFuzzTest, HpaeRendererManagerGetWritableSizeFuzzTest, diff --git a/test/fuzztest/istandardaudiozoneclient_fuzzer/i_standard_audio_zone_client_fuzzer.cpp b/test/fuzztest/istandardaudiozoneclient_fuzzer/i_standard_audio_zone_client_fuzzer.cpp index dfb6d762977eec4f08baf62872c57aa5f1162566..fb0325a8988845db99e7152cbfc186b2ba3a1db4 100644 --- a/test/fuzztest/istandardaudiozoneclient_fuzzer/i_standard_audio_zone_client_fuzzer.cpp +++ b/test/fuzztest/istandardaudiozoneclient_fuzzer/i_standard_audio_zone_client_fuzzer.cpp @@ -50,7 +50,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 1; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -89,7 +88,7 @@ void IStandardAudioZoneClientFuzzTest() example.~IStandardAudioZoneClientFuzz(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { IStandardAudioZoneClientFuzzTest, }; diff --git a/test/fuzztest/istandardspatializationstatechangelistener_fuzzer/i_standard_spatialization_state_change_listener_fuzzer.cpp b/test/fuzztest/istandardspatializationstatechangelistener_fuzzer/i_standard_spatialization_state_change_listener_fuzzer.cpp index e965d8d0bb26b09dfebaf16dda6c9b1bf3a33bbe..29438d3ac21bb632111ccd85fa99260d6d7f49ca 100644 --- a/test/fuzztest/istandardspatializationstatechangelistener_fuzzer/i_standard_spatialization_state_change_listener_fuzzer.cpp +++ b/test/fuzztest/istandardspatializationstatechangelistener_fuzzer/i_standard_spatialization_state_change_listener_fuzzer.cpp @@ -49,7 +49,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 1; static int32_t NUM_2 = 2; typedef void (*TestFuncs)(); @@ -86,7 +85,7 @@ void IStandardClientTrackerFuzzTest() example.~SpatializationListenerFuzz(); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { IStandardClientTrackerFuzzTest, }; diff --git a/test/fuzztest/offlineaudioeffectserverchain_fuzzer/BUILD.gn b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..34a9fe4a4594b06c266bb066625df3e780a89e51 --- /dev/null +++ b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/BUILD.gn @@ -0,0 +1,62 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../accessibility.gni") +import("../../../config.gni") + +ohos_fuzztest("OfflineAudioEffectServerChainFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../offlineaudioeffectserverchain_fuzzer" + + include_dirs = [ + "../../../frameworks/native/offlineaudioeffect/include", + "../../../interfaces/inner_api/native/audiocommon/include", + "../../../services/audio_service/common/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + configs = [] + + sources = [ "offline_audio_effect_server_chain_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_service:audio_common", + ] + + external_deps = [ + "c_utils:utils", + "drivers_interface_audio:libeffect_proxy_1.0", + "hilog:libhilog", + "ipc:ipc_single", + ] + + defines = [] + if (audio_framework_feature_offline_effect) { + deps += [ + "../../../frameworks/native/offlineaudioeffect:offline_audio_effect_service", + ] + defines += [ "FEATURE_OFFLINE_EFFECT" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":OfflineAudioEffectServerChainFuzzTest" ] +} diff --git a/test/fuzztest/offlineaudioeffectserverchain_fuzzer/corpus/init b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/offlineaudioeffectserverchain_fuzzer/offline_audio_effect_server_chain_fuzzer.cpp b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/offline_audio_effect_server_chain_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b5c5881e3008ca1fd5757cbbb69229f6b24fe391 --- /dev/null +++ b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/offline_audio_effect_server_chain_fuzzer.cpp @@ -0,0 +1,126 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "offline_audio_effect_server_chain.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; + +typedef void (*TestFuncs)(); + +void OfflineAudioEffectServerChainInitDumpFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + serverChain->InitDump(); +} + +void OfflineAudioEffectServerChainCreateFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + serverChain->Create(); +} + +void OfflineAudioEffectServerChainSetConfigFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + AudioStreamInfo inInfo; + inInfo.samplingRate = g_fuzzUtils.GetData(); + AudioStreamInfo outInfo; + serverChain->SetConfig(inInfo, outInfo); +} + +void OfflineAudioEffectServerChainSetParamFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + std::vector param; + param.push_back(g_fuzzUtils.GetData()); + serverChain->SetParam(param); +} + +void OfflineAudioEffectServerChainGetEffectBufferSizeFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + uint32_t inBufferSize; + uint32_t outBufferSize; + serverChain->inBufferSize_ = g_fuzzUtils.GetData(); + serverChain->outBufferSize_ = g_fuzzUtils.GetData(); + serverChain->GetEffectBufferSize(inBufferSize, outBufferSize); +} + +void OfflineAudioEffectServerChainPrepareFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + size_t inSize = g_fuzzUtils.GetData(); + std::string inName = "testBuffer"; + std::shared_ptr bufferIn = AudioSharedMemory::CreateFormLocal(inSize, inName); + size_t outSize = g_fuzzUtils.GetData(); + std::string outName = "testBuffer"; + std::shared_ptr bufferOut = AudioSharedMemory::CreateFormLocal(outSize, outName); + serverChain->Prepare(bufferIn, bufferOut); +} + +void OfflineAudioEffectServerChainProcessFuzzTest() +{ + shared_ptr serverChain = make_shared("serverChain"); + CHECK_AND_RETURN(serverChain != nullptr); + size_t inBufferSize = g_fuzzUtils.GetData(); + std::string inName = "testBuffer"; + std::shared_ptr bufferIn = AudioSharedMemory::CreateFormLocal(inBufferSize, inName); + size_t outBufferSize = g_fuzzUtils.GetData(); + std::string outName = "testBuffer"; + std::shared_ptr bufferOut = AudioSharedMemory::CreateFormLocal(outBufferSize, outName); + serverChain->inBufferSize_ = inBufferSize; + serverChain->outBufferSize_ = outBufferSize; + uint32_t inSize = g_fuzzUtils.GetData(); + uint32_t outSize = g_fuzzUtils.GetData(); + serverChain->Process(inSize, outSize); +} + +vector g_testFuncs = { + OfflineAudioEffectServerChainInitDumpFuzzTest, + OfflineAudioEffectServerChainCreateFuzzTest, + OfflineAudioEffectServerChainSetConfigFuzzTest, + OfflineAudioEffectServerChainSetParamFuzzTest, + OfflineAudioEffectServerChainGetEffectBufferSizeFuzzTest, + OfflineAudioEffectServerChainPrepareFuzzTest, + OfflineAudioEffectServerChainProcessFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { + return 0; + } + + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/offlineaudioeffectserverchain_fuzzer/project.xml b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/offlineaudioeffectserverchain_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/powerstatelistener_fuzzer/power_state_listener_fuzzer.cpp b/test/fuzztest/powerstatelistener_fuzzer/power_state_listener_fuzzer.cpp index e75d8ba693903026ec0a6cf853d3f5a0c10080a0..6a361e2881863fff90f4d21ae13b433e43ee6bfe 100644 --- a/test/fuzztest/powerstatelistener_fuzzer/power_state_listener_fuzzer.cpp +++ b/test/fuzztest/powerstatelistener_fuzzer/power_state_listener_fuzzer.cpp @@ -52,7 +52,6 @@ static const uint8_t* RAW_DATA = nullptr; static size_t g_dataSize = 0; static size_t g_pos; const size_t THRESHOLD = 10; -const uint8_t TESTSIZE = 6; typedef void (*TestFuncs)(); @@ -149,7 +148,7 @@ void SyncHibernateListenerStubOnRemoteRequestFuzzTest() syncHibernateListenerStub->OnRemoteRequest(code, data, reply, option); } -TestFuncs g_testFuncs[TESTSIZE] = { +TestFuncs g_testFuncs[] = { PowerStateListenerControlAudioFocusFuzzTest, OnSyncWakeupCallbackStubFuzzTest, OnSyncHibernateCallbackStubFuzzTest, diff --git a/test/fuzztest/simdutils_fuzzer/BUILD.gn b/test/fuzztest/simdutils_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..9bd3a4f42cad5a893071391d45bb32655deccee4 --- /dev/null +++ b/test/fuzztest/simdutils_fuzzer/BUILD.gn @@ -0,0 +1,52 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("//build/ohos.gni") + +config("audio_engine_private_config") { + + include_dirs = [ + "../../../services/audio_engine/simd", + "../../../frameworks/native/audioeffect/include", + ] +} + +ohos_fuzztest("SimdUtilsFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../simdutils_fuzzer" + + include_dirs = [ + "../../../services/audio_policy/server/domain/volume/include", + "../../../interfaces/inner_api/native/audiocommon/include", + ] + + configs = [ ":audio_engine_private_config" ] + + sources = [ "simd_utils_fuzzer.cpp" ] + + deps = [ + "../../../services/audio_engine:audio_engine_utils" + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] +} + +group("fuzztest") { + testonly = true + deps = [ ":SimdUtilsFuzzTest" ] +} diff --git a/test/fuzztest/simdutils_fuzzer/corpus/init b/test/fuzztest/simdutils_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8f37f09254457133cae0f828d0a5faee7dcbd779 --- /dev/null +++ b/test/fuzztest/simdutils_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +FUZZ \ No newline at end of file diff --git a/test/fuzztest/simdutils_fuzzer/project.xml b/test/fuzztest/simdutils_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/simdutils_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/simdutils_fuzzer/simd_utils_fuzzer.cpp b/test/fuzztest/simdutils_fuzzer/simd_utils_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7419bf8529148ccd82a9f4295f81fd16e347f7d7 --- /dev/null +++ b/test/fuzztest/simdutils_fuzzer/simd_utils_fuzzer.cpp @@ -0,0 +1,99 @@ +/* +* Copyright (c) 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 +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include +#include +#include +#include +#include "audio_device_info.h" +#include "simd_utils.h" +#include "audio_effect_volume.h" +#include "../fuzz_utils.h" + +using namespace std; +using namespace OHOS::AudioStandard::HPAE; +namespace OHOS { +namespace AudioStandard { +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +typedef void (*TestFuncs)(); +const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; +const size_t ROW_LENGTH = 5; + +void SimdUtilsSimdPointByPointAddFuzzTest() +{ + const uint8_t randomLength = (g_fuzzUtils.GetData() % ROW_LENGTH) + 1; + + std::vector inputLeft(randomLength); + std::vector inputRight(randomLength); + std::vector output(randomLength); + + for (size_t i = 0; i < randomLength; ++i) { + inputLeft[i] = g_fuzzUtils.GetData(); + inputRight[i] = g_fuzzUtils.GetData(); + } + + SimdPointByPointAdd(randomLength, inputLeft.data(), inputRight.data(), output.data()); +} + +void SimdUtilsSimdPointByPointSubFuzzTest() +{ + const uint8_t randomLength = (g_fuzzUtils.GetData() % ROW_LENGTH) + 1; + + std::vector inputLeft(randomLength); + std::vector inputRight(randomLength); + std::vector output(randomLength); + + for (size_t i = 0; i < randomLength; ++i) { + inputLeft[i] = g_fuzzUtils.GetData(); + inputRight[i] = g_fuzzUtils.GetData(); + } + + SimdPointByPointSub(randomLength, inputLeft.data(), inputRight.data(), output.data()); +} + +void SimdUtilsSimdPointByPointMulFuzzTest() +{ + const uint8_t randomLength = (g_fuzzUtils.GetData() % ROW_LENGTH) + 1; + + std::vector inputLeft(randomLength); + std::vector inputRight(randomLength); + std::vector output(randomLength); + + for (size_t i = 0; i < randomLength; ++i) { + inputLeft[i] = g_fuzzUtils.GetData(); + inputRight[i] = g_fuzzUtils.GetData(); + } + + SimdPointByPointMul(randomLength, inputLeft.data(), inputRight.data(), output.data()); +} + +vector g_testFuncs = { + SimdUtilsSimdPointByPointAddFuzzTest, + SimdUtilsSimdPointByPointSubFuzzTest, + SimdUtilsSimdPointByPointMulFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { + return 0; + } + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +}