From 4dce1b43732156c543f16e5e09e2d15441f22751 Mon Sep 17 00:00:00 2001 From: zhengyong Date: Thu, 10 Jul 2025 15:47:23 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90=E5=BA=95=E5=BA=A7=E8=83=BD=E5=8A=9B?= =?UTF-8?q?=E4=BD=93=E9=AA=8C=E5=A2=9E=E5=BC=BA=E3=80=91=E6=8F=90=E4=BE=9B?= =?UTF-8?q?=E6=8C=89=E9=94=AE=E8=B0=83=E8=8A=82=E9=9F=B3=E6=98=9F=E7=B1=BB?= =?UTF-8?q?=E5=9E=8B=E4=BF=9D=E6=8C=81=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhengyong --- .../napi_audio_volume_manager.cpp | 50 ++++++++++++ .../audiomanager/napi_audio_volume_manager.h | 3 + .../include/audio_policy_manager.h | 2 + .../include/audio_system_manager.h | 10 +++ .../service/src/audio_policy_manager.cpp | 9 +++ services/audio_policy/idl/IAudioPolicy.idl | 1 + .../volume/include/audio_volume_manager.h | 30 +++++++ .../volume/src/audio_volume_manager.cpp | 81 +++++++++++++++++++ .../include/audio_policy_server.h | 3 + .../service_main/src/audio_policy_server.cpp | 31 +++++-- .../src/audio_volume_manager_unit_test.cpp | 28 +++++++ .../client/src/audio_system_manager.cpp | 6 ++ .../audio_policy_more_fuzzer.cpp | 14 +++- .../audio_volume_manager_fuzzer.cpp | 8 ++ 14 files changed, 270 insertions(+), 6 deletions(-) diff --git a/frameworks/js/napi/audiomanager/napi_audio_volume_manager.cpp b/frameworks/js/napi/audiomanager/napi_audio_volume_manager.cpp index 8a11d438d2..d304de93d0 100644 --- a/frameworks/js/napi/audiomanager/napi_audio_volume_manager.cpp +++ b/frameworks/js/napi/audiomanager/napi_audio_volume_manager.cpp @@ -174,6 +174,7 @@ napi_value NapiAudioVolumeManager::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("getStreamUsagesByVolumeType", GetStreamUsagesByVolumeType), DECLARE_NAPI_FUNCTION("on", On), DECLARE_NAPI_FUNCTION("off", Off), + DECLARE_NAPI_FUNCTION("forceVolumeKeyControlType", ForceVolumeKeyControlType), }; status = napi_define_class(env, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr, @@ -1524,5 +1525,54 @@ std::shared_ptr NapiAudioVolumeManager::Get } return cb; } + +napi_value NapiAudioVolumeManager::ForceVolumeKeyControlType(napi_env env, napi_callback_info info) +{ + auto context = std::make_shared(); + if (context == nullptr) { + AUDIO_ERR_LOG("ForceVolumeKeyControlType failed : no memory"); + NapiAudioError::ThrowError(env, "ForceVolumeKeyControlType failed : no memory", NAPI_ERR_SYSTEM); + return NapiParamUtils::GetUndefinedValue(env); + } + size_t argNum = 0; + auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) { + argNum = argc; + NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, " Invalid arguments count or types.", + NAPI_ERR_INVALID_PARAM); + context->status = NapiParamUtils::GetValueInt32(env, context->volumeType, argv[PARAM0]); + NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volumeType failed", + NAPI_ERR_INPUT_INVALID); + context->status = NapiParamUtils::GetValueInt32(env, context->duration, argv[PARAM1]); + NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get duration failed", + NAPI_ERR_INPUT_INVALID); + }; + context->GetCbInfo(env, info, inputParser); + + auto executor = [context]() { + CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error."); + auto obj = reinterpret_cast(context->native); + ObjectRefMap objectGuard(obj); + auto *napiAudioVolumeManager = objectGuard.GetPtr(); + CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context), + "audio volume manager state is error."); + context->intValue = napiAudioVolumeManager->audioSystemMngr_->ForceVolumeKeyControlType( + static_cast(context->volumeType), context->duration); + CHECK_AND_RETURN(context->intValue != SUCCESS); + if (context->intValue == ERR_PERMISSION_DENIED) { + context->SignError(NAPI_ERR_NO_PERMISSION); + } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) { + context->SignError(NAPI_ERR_PERMISSION_DENIED); + } else if (context->intValue == ERR_INVALID_PARAM) { + context->SignError(NAPI_ERR_INVALID_PARAM); + } else { + context->SignError(NAPI_ERR_SYSTEM, "ForceVolumeKeyControlType fail."); + } + }; + + auto complete = [env](napi_value &output) { + output = NapiParamUtils::GetUndefinedValue(env); + }; + return NapiAsyncWork::Enqueue(env, context, "ForceVolumeKeyControlType", executor, complete); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/audiomanager/napi_audio_volume_manager.h b/frameworks/js/napi/audiomanager/napi_audio_volume_manager.h index 3bef81a50f..f1149654e8 100644 --- a/frameworks/js/napi/audiomanager/napi_audio_volume_manager.h +++ b/frameworks/js/napi/audiomanager/napi_audio_volume_manager.h @@ -52,6 +52,8 @@ private: bool isOwned; std::string networkId; std::vector> volumeGroupInfos; + int32_t volumeType; + int32_t duration; }; static bool CheckContextStatus(std::shared_ptr context); @@ -119,6 +121,7 @@ private: static napi_value Construct(napi_env env, napi_callback_info info); static void Destructor(napi_env env, void *nativeObject, void *finalizeHint); + static napi_value ForceVolumeKeyControlType(napi_env env, napi_callback_info info); AudioSystemManager *audioSystemMngr_; int32_t cachedClientId_ = -1; diff --git a/frameworks/native/audiopolicy/include/audio_policy_manager.h b/frameworks/native/audiopolicy/include/audio_policy_manager.h index 1f4fbacc13..ae99c9656c 100644 --- a/frameworks/native/audiopolicy/include/audio_policy_manager.h +++ b/frameworks/native/audiopolicy/include/audio_policy_manager.h @@ -665,6 +665,8 @@ public: const std::shared_ptr &selectedAudioDevice, bool enabled); bool IsCollaborativePlaybackEnabledForDevice( const std::shared_ptr &selectedAudioDevice); + int32_t ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration); + private: AudioPolicyManager() {} ~AudioPolicyManager() {} 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 30fbb9f742..e41414e65a 100644 --- a/interfaces/inner_api/native/audiomanager/include/audio_system_manager.h +++ b/interfaces/inner_api/native/audiomanager/include/audio_system_manager.h @@ -1762,6 +1762,16 @@ public: */ int32_t StopGroup(int32_t workgroupId); + /** + * @brief set focus stream type when process volume key event. + * + * @param volumeType Audio stream type. + * @param duration duration time to last or cancel force type. + * @return Returns {@link AUDIO_OK} if the operation is successfully. + * @test + */ + int32_t ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration); + private: class WakeUpCallbackImpl : public WakeUpSourceCallback { public: diff --git a/services/audio_policy/client/service/src/audio_policy_manager.cpp b/services/audio_policy/client/service/src/audio_policy_manager.cpp index 06edcebe97..8d4e890923 100644 --- a/services/audio_policy/client/service/src/audio_policy_manager.cpp +++ b/services/audio_policy/client/service/src/audio_policy_manager.cpp @@ -3054,6 +3054,15 @@ bool AudioPolicyManager::IsCapturerFocusAvailable(const AudioCapturerInfo &captu return isAvailable; } +int32_t AudioPolicyManager::ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration) +{ + const sptr gsp = GetAudioPolicyManagerProxy(); + CHECK_AND_RETURN_RET_LOG(gsp != nullptr, false, "audio policy manager proxy is NULL."); + int32_t ret = ERROR; + gsp->ForceVolumeKeyControlType(static_cast(volumeType), duration, ret); + return ret; +} + AudioPolicyManager& AudioPolicyManager::GetInstance() { static AudioPolicyManager policyManager; diff --git a/services/audio_policy/idl/IAudioPolicy.idl b/services/audio_policy/idl/IAudioPolicy.idl index 4ae0492848..f69b5d1abf 100644 --- a/services/audio_policy/idl/IAudioPolicy.idl +++ b/services/audio_policy/idl/IAudioPolicy.idl @@ -288,6 +288,7 @@ interface IAudioPolicy { void SetAudioSessionScene([in] int audioSessionScene /* AudioSessionScene */); void GetDefaultOutputDevice([out] int deviceType /* deviceType */); void SetDefaultOutputDevice([in] int deviceType /* deviceType */); + void ForceVolumeKeyControlType([in] int volumeType, [in] int duration, [out] int ret); // WARNING: above functions correspond with AudioPolicyInterfaceCode } 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 9dafd2fd5f..f4480df10f 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 @@ -45,10 +45,13 @@ #include "audio_scene_manager.h" #include "audio_connected_device.h" #include "audio_offload_stream.h" +#include "audio_policy_state_monitor.h" namespace OHOS { namespace AudioStandard { +class ForceControlVolumeTypeMonitor; + using InternalDeviceType = DeviceType; struct AdjustVolumeInfo { @@ -128,6 +131,11 @@ public: std::vector> GetAllDeviceVolumeInfo(); void GetVolumeKeyRegistrationInfo(std::vector &keyRegistrationInfo); int32_t SaveSpecifiedDeviceVolume(AudioStreamType streamType, int32_t volumeLevel, DeviceType deviceType); + int32_t ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration); + void OnTimerExpired(); + bool IsNeedForceControlVolumeType(); + AudioVolumeType GetForceControlVolumeType(); + private: AudioVolumeManager() : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), audioA2dpDevice_(AudioA2dpDevice::GetInstance()), @@ -224,8 +232,30 @@ private: AudioConnectedDevice& audioConnectedDevice_; AudioOffloadStream& audioOffloadStream_; std::shared_ptr audioPolicyServerHandler_; + std::mutex forceControlVolumeTypeMutex_; + bool needForceControlVolumeType_ = false; + AudioVolumeType forceControlVolumeType_ = STREAM_DEFAULT; + std::shared_ptr forceControlVolumeTypeMonitor_; }; +class ForceControlVolumeTypeMonitor : public AudioPolicyStateMonitorCallback { +public: + ForceControlVolumeTypeMonitor() : audioVolumeManager_(AudioVolumeManager::GetInstance()) {}; + ~ForceControlVolumeTypeMonitor(); + void OnTimeOut() override; + void SetTimer(int32_t duration, std::shared_ptr cb); + +private: + static constexpr int32_t MAX_DURATION_TIME_S = 10; + + void StartMonitor(int32_t duration, std::shared_ptr cb); + void StopMonitor(); + + AudioVolumeManager &audioVolumeManager_; + int32_t duration_ = 0; + int32_t cbId_ = INVALID_CB_ID; + std::mutex mtx_; +}; } } 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 44289d7ebe..a6a7559578 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 @@ -96,6 +96,8 @@ bool AudioVolumeManager::Init(std::shared_ptr audioPol sharedAbsVolumeScene_ = reinterpret_cast(policyVolumeMap_->GetBase()) + IPolicyProvider::GetVolumeVectorSize() * sizeof(Volume); } + CHECK_AND_RETURN_RET(forceControlVolumeTypeMonitor_ == nullptr, true); + forceControlVolumeTypeMonitor_ = std::make_shared(); return true; } void AudioVolumeManager::DeInit(void) @@ -104,6 +106,7 @@ void AudioVolumeManager::DeInit(void) sharedAbsVolumeScene_ = nullptr; policyVolumeMap_ = nullptr; safeVolumeExit_ = true; + forceControlVolumeTypeMonitor_ = nullptr; if (calculateLoopSafeTime_ != nullptr && calculateLoopSafeTime_->joinable()) { calculateLoopSafeTime_->join(); calculateLoopSafeTime_.reset(); @@ -1339,5 +1342,83 @@ void AudioVolumeManager::GetVolumeKeyRegistrationInfo(std::vectorGetData(); } + +int32_t AudioVolumeManager::ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration) +{ + CHECK_AND_RETURN_RET_LOG(duration >= -1, ERR_INVALID_PARAM, "invalid duration"); + CHECK_AND_RETURN_RET_LOG(forceControlVolumeTypeMonitor_ != nullptr, ERR_UNKNOWN, + "forceControlVolumeTypeMonitor_ is nullptr"); + std::lock_guard lock(forceControlVolumeTypeMutex_); + needForceControlVolumeType_ = (duration == -1 ? false : true); + forceControlVolumeType_ = (duration == -1 ? STREAM_DEFAULT : volumeType); + forceControlVolumeTypeMonitor_->SetTimer(duration, forceControlVolumeTypeMonitor_); + return SUCCESS; +} + +void AudioVolumeManager::OnTimerExpired() +{ + std::lock_guard lock(forceControlVolumeTypeMutex_); + needForceControlVolumeType_ = false; + forceControlVolumeType_ = STREAM_DEFAULT; +} + +bool AudioVolumeManager::IsNeedForceControlVolumeType() +{ + std::lock_guard lock(forceControlVolumeTypeMutex_); + return needForceControlVolumeType_; +} + +AudioVolumeType AudioVolumeManager::GetForceControlVolumeType() +{ + std::lock_guard lock(forceControlVolumeTypeMutex_); + return forceControlVolumeType_; +} + +ForceControlVolumeTypeMonitor::~ForceControlVolumeTypeMonitor() +{ + std::lock_guard lock(mtx_); + StopMonitor(); +} + +void ForceControlVolumeTypeMonitor::OnTimeOut() +{ + { + std::lock_guard lock(mtx_); + StopMonitor(); + } + audioVolumeManager_.OnTimerExpired(); +} + +void ForceControlVolumeTypeMonitor::StartMonitor(int32_t duration, + std::shared_ptr cb) +{ + int32_t cbId = DelayedSingleton::GetInstance()->RegisterCallback( + cb, duration, CallbackType::ONE_TIME); + if (cbId == INVALID_CB_ID) { + AUDIO_ERR_LOG("Register AudioPolicyStateMonitor failed"); + } else { + cbId_ = cbId; + } +} + +void ForceControlVolumeTypeMonitor::StopMonitor() +{ + if (cbId_ != INVALID_CB_ID) { + DelayedSingleton::GetInstance()->UnRegisterCallback(cbId_); + cbId_ = INVALID_CB_ID; + } +} + +void ForceControlVolumeTypeMonitor::SetTimer(int32_t duration, + std::shared_ptr cb) +{ + std::lock_guard lock(mtx_); + StopMonitor(); + if (duration == -1) { + return; + } + duration_ = (duration > MAX_DURATION_TIME_S ? MAX_DURATION_TIME_S : duration); + StartMonitor(duration_, cb); +} } } 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 6c44278bb5..76b87bc6f9 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 @@ -581,6 +581,8 @@ public: int32_t IsCapturerFocusAvailable(const AudioCapturerInfo &capturerInfo, bool &ret) override; + int32_t ForceVolumeKeyControlType(int32_t volumeType, int32_t duration, int32_t &ret) override; + void ProcessRemoteInterrupt(std::set sessionIds, InterruptEventInternal interruptEvent); void SendVolumeKeyEventCbWithUpdateUiOrNot(AudioStreamType streamType, const bool& isUpdateUi = false, @@ -794,6 +796,7 @@ private: void UpdateDefaultOutputDeviceWhenStarting(const uint32_t sessionID); void UpdateDefaultOutputDeviceWhenStopping(const uint32_t sessionID); void ChangeVolumeOnVoiceAssistant(AudioStreamType &streamInFocus); + AudioStreamType GetCurrentStreamInFocus(const AudioStreamType streamInFocus); AudioEffectService &audioEffectService_; AudioAffinityManager &audioAffinityManager_; diff --git a/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp b/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp index ab661d3b6a..b1f6f0e22c 100644 --- a/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp +++ b/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp @@ -534,7 +534,7 @@ void AudioPolicyServer::TriggerMuteCheck() // print volume info int32_t streamType = STREAM_DEFAULT; GetStreamInFocus(DEFAULT_ZONEID, streamType); - AudioStreamType streamInFocus = static_cast(streamType); + AudioStreamType streamInFocus = GetCurrentStreamInFocus(static_cast(streamType)); int32_t volume = GetSystemVolumeLevelInternal(VolumeUtils::GetVolumeTypeFromStreamType(streamInFocus)); AUDIO_WARNING_LOG("StreamInFocus is [%{public}d], volume is %{public}d", streamInFocus, volume); } @@ -553,7 +553,8 @@ int32_t AudioPolicyServer::ProcessVolumeKeyEvents(const int32_t keyType) } else { int32_t streamType = STREAM_DEFAULT; GetStreamInFocus(zoneId, streamType); - streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(static_cast(streamType)); + streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType( + GetCurrentStreamInFocus(static_cast(streamType))); } bool active = false; IsStreamActive(streamInFocus, active); @@ -621,7 +622,8 @@ int32_t AudioPolicyServer::RegisterVolumeKeyMuteEvents() int32_t zoneID = 0; int32_t streamType = STREAM_DEFAULT; GetStreamInFocus(zoneID, streamType); - streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(static_cast(streamType)); + streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType( + GetCurrentStreamInFocus(static_cast(streamType))); } std::lock_guard lock(systemVolumeMutex_); isStreamMuted = GetStreamMuteInternal(streamInFocus); @@ -1067,7 +1069,8 @@ AudioStreamType AudioPolicyServer::GetSystemActiveVolumeTypeInternal(const int32 int32_t streamType = STREAM_DEFAULT; GetStreamInFocus(zoneID, streamType); AudioStreamType streamInFocus = STREAM_DEFAULT; - streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(static_cast(streamType)); + streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType( + GetCurrentStreamInFocus(static_cast(streamType))); if (clientUid != 0) { GetStreamInFocusByUid(clientUid, zoneID, streamType); streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(static_cast(streamType)); @@ -1200,7 +1203,8 @@ int32_t AudioPolicyServer::AdjustVolumeByStep(int32_t adjustTypeIn) int32_t zoneID = 0; int32_t streamType = STREAM_DEFAULT; GetStreamInFocus(zoneID, streamType); - AudioStreamType streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(static_cast(streamType)); + AudioStreamType streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType( + GetCurrentStreamInFocus(static_cast(streamType))); if (streamInFocus == AudioStreamType::STREAM_DEFAULT) { streamInFocus = AudioStreamType::STREAM_MUSIC; } @@ -2528,6 +2532,13 @@ void AudioPolicyServer::OnAudioStreamRemoved(const uint64_t sessionID) audioPolicyServerHandler_->SendCapturerRemovedEvent(sessionID, false); } +AudioStreamType AudioPolicyServer::GetCurrentStreamInFocus(const AudioStreamType streamInFocus) +{ + CHECK_AND_RETURN_RET(audioVolumeManager_.IsNeedForceControlVolumeType(), streamInFocus); + AUDIO_INFO_LOG("force volume type, type:%{public}d", audioVolumeManager_.GetForceControlVolumeType()); + return audioVolumeManager_.GetForceControlVolumeType(); +} + int32_t AudioPolicyServer::GetStreamInFocus(int32_t zoneID, int32_t &streamType) { if (interruptService_ != nullptr) { @@ -4846,6 +4857,16 @@ int32_t AudioPolicyServer::IsCapturerFocusAvailable(const AudioCapturerInfo &cap return SUCCESS; } +int32_t AudioPolicyServer::ForceVolumeKeyControlType(int32_t volumeType, int32_t duration, int32_t &ret) +{ + CHECK_AND_RETURN_RET_LOG(VerifyPermission(MODIFY_AUDIO_SETTINGS_PERMISSION), ERR_PERMISSION_DENIED, + "MODIFY_AUDIO_SETTINGS_PERMISSION permission check failed"); + CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySystemPermission(), + ERR_SYSTEM_PERMISSION_DENIED, "no system permission"); + ret = audioVolumeManager_.ForceVolumeKeyControlType(static_cast(volumeType), duration); + return SUCCESS; +} + void AudioPolicyServer::UpdateDefaultOutputDeviceWhenStarting(const uint32_t sessionID) { audioDeviceManager_.UpdateDefaultOutputDeviceWhenStarting(sessionID); diff --git a/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_unit_test.cpp index cfebffe09f..4d704db77d 100644 --- a/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_unit_test.cpp @@ -469,6 +469,34 @@ HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_022, TestSize.Level1) audioVolumeManager->audioConnectedDevice_.AddConnectedDevice(remoteDeviceDescriptor); audioVolumeManager->GetAllDeviceVolumeInfo(); } + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: AudioVolumeManager_023 +* @tc.desc : Test ForceVolumeKeyControlType interface. +*/ +HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_023, TestSize.Level1) +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + audioVolumeManager.ForceVolumeKeyControlType(STREAM_RING, 3); + EXPECT_EQ(audioVolumeManager.forceControlVolumeType_, STREAM_RING); + EXPECT_EQ(audioVolumeManager.needForceControlVolumeType_, true); + + audioVolumeManager.ForceVolumeKeyControlType(STREAM_MEDIA, 3); + EXPECT_EQ(audioVolumeManager.forceControlVolumeType_, STREAM_MEDIA); + EXPECT_EQ(audioVolumeManager.needForceControlVolumeType_, true); + + audioVolumeManager.ForceVolumeKeyControlType(STREAM_MEDIA, -1); + EXPECT_EQ(audioVolumeManager.forceControlVolumeType_, STREAM_DEFAULT); + EXPECT_EQ(audioVolumeManager.needForceControlVolumeType_, false); + + audioVolumeManager.ForceVolumeKeyControlType(STREAM_MEDIA, 1); + EXPECT_EQ(audioVolumeManager.forceControlVolumeType_, STREAM_MEDIA); + EXPECT_EQ(audioVolumeManager.needForceControlVolumeType_, true); + usleep(1500000); + EXPECT_EQ(audioVolumeManager.forceControlVolumeType_, STREAM_DEFAULT); + EXPECT_EQ(audioVolumeManager.needForceControlVolumeType_, false); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/audio_system_manager.cpp b/services/audio_service/client/src/audio_system_manager.cpp index 31d6dbe83c..b7e7c4fb60 100644 --- a/services/audio_service/client/src/audio_system_manager.cpp +++ b/services/audio_service/client/src/audio_system_manager.cpp @@ -2225,5 +2225,11 @@ bool AudioSystemManager::IsValidToStartGroup(int32_t workgroupId) } return false; } + +int32_t AudioSystemManager::ForceVolumeKeyControlType(AudioVolumeType volumeType, int32_t duration) +{ + AUDIO_INFO_LOG("volumeType:%{public}d, dyration:%{public}d", volumeType, duration); + return AudioPolicyManager::GetInstance().ForceVolumeKeyControlType(volumeType, duration); +} } // namespace AudioStandard } // namespace OHOS diff --git a/test/fuzztest/audiopolicymore_fuzzer/audio_policy_more_fuzzer.cpp b/test/fuzztest/audiopolicymore_fuzzer/audio_policy_more_fuzzer.cpp index cd26cfe030..2ccca3f0f0 100644 --- a/test/fuzztest/audiopolicymore_fuzzer/audio_policy_more_fuzzer.cpp +++ b/test/fuzztest/audiopolicymore_fuzzer/audio_policy_more_fuzzer.cpp @@ -443,7 +443,18 @@ void AudioPolicyManagerFuzzTest() #endif } -typedef void (*TestFuncs[15])(); +void ForceVolumeKeyControlTypeFuzzTest() +{ + std::shared_ptr interruptService = std::make_shared(); + int32_t volumeType = GetData(); + int32_t duration = GetData(); + if (interruptService == nullptr) { + return; + } + interruptService->ForceVolumeKeyControlType(static_cast(volumeType), duration); +} + +typedef void (*TestFuncs[16])(); TestFuncs g_testFuncs = { InitFuzzTest, @@ -459,6 +470,7 @@ TestFuncs g_testFuncs = { AudioPolicyOtherMoreFuzzTest, AudioVolumeKeyCallbackStubMoreFuzzTest, AudioPolicyManagerFuzzTest, + ForceVolumeKeyControlTypeFuzzTest, }; bool FuzzTest(const uint8_t* rawData, size_t size) diff --git a/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp b/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp index f7f6696acb..6bcca129ba 100644 --- a/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp +++ b/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp @@ -379,6 +379,13 @@ void AudioVolumeManagerInitKVStoreFuzzTest(const uint8_t *rawData, size_t size) audioVolumeManager.InitKVStore(); } +void AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest(const uint8_t *rawData, size_t size) +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.ForceVolumeKeyControlType(static_cast(size), size); +} + } // namespace AudioStandard } // namesapce OHOS @@ -404,6 +411,7 @@ OHOS::AudioStandard::TestPtr g_testPtrs[] = { OHOS::AudioStandard::AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest, OHOS::AudioStandard::AudioVolumeManagerInitFuzzTest, OHOS::AudioStandard::AudioVolumeManagerInitKVStoreFuzzTest, + OHOS::AudioStandard::AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest, }; /* Fuzzer entry point */ -- Gitee