diff --git a/frameworks/js/napi/audiomanager/napi_audio_volume_manager.cpp b/frameworks/js/napi/audiomanager/napi_audio_volume_manager.cpp
index 8a11d438d20b18aa05113d877cdf32d363233242..d304de93d07988bb69c567df9082e208d184c794 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<NapiAudioSystemVolumeChangeCallback> NapiAudioVolumeManager::Get
     }
     return cb;
 }
+
+napi_value NapiAudioVolumeManager::ForceVolumeKeyControlType(napi_env env, napi_callback_info info)
+{
+    auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
+    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<NapiAudioVolumeManager*>(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<AudioVolumeType>(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 3bef81a50f682cf2b154cd763cf0a1f00fe546e2..f1149654e88a6f2388880a28d3892731503b9e8d 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<sptr<VolumeGroupInfo>> volumeGroupInfos;
+        int32_t volumeType;
+        int32_t duration;
     };
 
     static bool CheckContextStatus(std::shared_ptr<AudioVolumeManagerAsyncContext> 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 1f4fbacc1371c40f406d6ea1e416108404ee1917..ae99c9656c2f5470e3c99f7f8ebbcf9e069a37c6 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<AudioDeviceDescriptor> &selectedAudioDevice, bool enabled);
     bool IsCollaborativePlaybackEnabledForDevice(
         const std::shared_ptr<AudioDeviceDescriptor> &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 30fbb9f742ea5ea3378a370a244838274bb1b114..e41414e65aea951f0ccae7b0fda4aeccf08cb397 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 06edcebe976eef201dc11c8bea6268dae0fcfa32..8d4e890923a6a90c14fa86853ec276c6092fe0f3 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<IAudioPolicy> gsp = GetAudioPolicyManagerProxy();
+    CHECK_AND_RETURN_RET_LOG(gsp != nullptr, false, "audio policy manager proxy is NULL.");
+    int32_t ret = ERROR;
+    gsp->ForceVolumeKeyControlType(static_cast<int32_t>(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 4ae0492848e7ee5f4f522a93969a2eee5978a146..f69b5d1abfeebf4a6f3fac6bfa30b149b5de95bc 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 9dafd2fd5f73ef75171ce8cb1244933eb1b328af..f4480df10fa69c90d6065751153f59744ce22d9b 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<std::shared_ptr<AllDeviceVolumeInfo>> GetAllDeviceVolumeInfo();
     void GetVolumeKeyRegistrationInfo(std::vector<VolumeKeyEventRegistration> &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> audioPolicyServerHandler_;
+    std::mutex forceControlVolumeTypeMutex_;
+    bool needForceControlVolumeType_ = false;
+    AudioVolumeType forceControlVolumeType_ = STREAM_DEFAULT;
+    std::shared_ptr<ForceControlVolumeTypeMonitor> forceControlVolumeTypeMonitor_;
 };
 
+class ForceControlVolumeTypeMonitor : public AudioPolicyStateMonitorCallback {
+public:
+    ForceControlVolumeTypeMonitor() : audioVolumeManager_(AudioVolumeManager::GetInstance()) {};
+    ~ForceControlVolumeTypeMonitor();
+    void OnTimeOut() override;
+    void SetTimer(int32_t duration, std::shared_ptr<ForceControlVolumeTypeMonitor> cb);
+
+private:
+    static constexpr int32_t MAX_DURATION_TIME_S = 10;
+
+    void StartMonitor(int32_t duration, std::shared_ptr<ForceControlVolumeTypeMonitor> 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 44289d7ebe475087c125a9e40d8402404122b6fe..a6a7559578379bbed8e405ded0d9276f2549f879 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<AudioPolicyServerHandler> audioPol
         sharedAbsVolumeScene_ = reinterpret_cast<bool *>(policyVolumeMap_->GetBase()) +
             IPolicyProvider::GetVolumeVectorSize() * sizeof(Volume);
     }
+    CHECK_AND_RETURN_RET(forceControlVolumeTypeMonitor_ == nullptr, true);
+    forceControlVolumeTypeMonitor_ = std::make_shared<ForceControlVolumeTypeMonitor>();
     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::vector<VolumeKeyEvent
 {
     keyRegistrationInfo = volumeKeyRegistrations_->GetData();
 }
+
+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<std::mutex> 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<std::mutex> lock(forceControlVolumeTypeMutex_);
+    needForceControlVolumeType_ = false;
+    forceControlVolumeType_ = STREAM_DEFAULT;
+}
+
+bool AudioVolumeManager::IsNeedForceControlVolumeType()
+{
+    std::lock_guard<std::mutex> lock(forceControlVolumeTypeMutex_);
+    return needForceControlVolumeType_;
+}
+
+AudioVolumeType AudioVolumeManager::GetForceControlVolumeType()
+{
+    std::lock_guard<std::mutex> lock(forceControlVolumeTypeMutex_);
+    return forceControlVolumeType_;
+}
+
+ForceControlVolumeTypeMonitor::~ForceControlVolumeTypeMonitor()
+{
+    std::lock_guard<std::mutex> lock(mtx_);
+    StopMonitor();
+}
+
+void ForceControlVolumeTypeMonitor::OnTimeOut()
+{
+    {
+        std::lock_guard<std::mutex> lock(mtx_);
+        StopMonitor();
+    }
+    audioVolumeManager_.OnTimerExpired();
+}
+
+void ForceControlVolumeTypeMonitor::StartMonitor(int32_t duration,
+    std::shared_ptr<ForceControlVolumeTypeMonitor> cb)
+{
+    int32_t cbId = DelayedSingleton<AudioPolicyStateMonitor>::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<AudioPolicyStateMonitor>::GetInstance()->UnRegisterCallback(cbId_);
+        cbId_ = INVALID_CB_ID;
+    }
+}
+
+void ForceControlVolumeTypeMonitor::SetTimer(int32_t duration,
+    std::shared_ptr<ForceControlVolumeTypeMonitor> cb)
+{
+    std::lock_guard<std::mutex> 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 6c44278bb53d7730854f2f94e59e35fa08dede11..76b87bc6f91a6ed7d42cfa0f604ac4326e97b8ce 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<int32_t> 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 ab661d3b6a77794bb6a2ab922a97ba14bde42c06..b1f6f0e22c87b8f05c07cb12aa76613c50f28eb9 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<AudioStreamType>(streamType);
+        AudioStreamType streamInFocus = GetCurrentStreamInFocus(static_cast<AudioStreamType>(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<AudioStreamType>(streamType));
+        streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(
+            GetCurrentStreamInFocus(static_cast<AudioStreamType>(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<AudioStreamType>(streamType));
+                streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(
+                    GetCurrentStreamInFocus(static_cast<AudioStreamType>(streamType)));
             }
             std::lock_guard<std::mutex> 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<AudioStreamType>(streamType));
+    streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(
+        GetCurrentStreamInFocus(static_cast<AudioStreamType>(streamType)));
     if (clientUid != 0) {
         GetStreamInFocusByUid(clientUid, zoneID, streamType);
         streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(static_cast<AudioStreamType>(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<AudioStreamType>(streamType));
+    AudioStreamType streamInFocus = VolumeUtils::GetVolumeTypeFromStreamType(
+        GetCurrentStreamInFocus(static_cast<AudioStreamType>(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<AudioVolumeType>(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 cfebffe09f83c0ff32366ea06b7e601400283ca2..4d704db77d667c405c4849bbbb7dfb00f7259999 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 31d6dbe83c4d7aa21cda9618c9667d5f1b4cbbf8..b7e7c4fb6067a7c26ec9f8bb86621c569def3d3e 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 cd26cfe0309f76d93fd3829579ee8da3f87aac37..2ccca3f0f02b278e5985c6f4c8d57cb7e1b54c91 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<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
+    int32_t volumeType = GetData<int32_t>();
+    int32_t duration = GetData<int32_t>();
+    if (interruptService == nullptr) {
+        return;
+    }
+    interruptService->ForceVolumeKeyControlType(static_cast<AudioVolumeType>(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 f7f6696acbc3c50c13ca0dcd2c276baea9375a45..6bcca129ba1ca8005d5a7080f2ccb82f4e718594 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<AudioVolumeType>(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 */