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 8b6e2916984ac1e3dbce71358eb4df16f90ddcb9..365718302e86445c4fd876e3973ff6e97e0354ab 100644
--- a/interfaces/inner_api/native/audiocommon/include/audio_device_descriptor.h
+++ b/interfaces/inner_api/native/audiocommon/include/audio_device_descriptor.h
@@ -99,6 +99,8 @@ public:
 
     bool IsDistributedSpeaker() const;
 
+    bool IsSpeakerOrEarpiece() const;
+
     bool IsRemote() const;
 
     DeviceType MapInternalToExternalDeviceType(int32_t apiVersion, bool isSupportedNearlink = true) const;
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 df95f47a56f1691314328bc3e6852a25568ed16e..1f7a1360a7e26ccdbed003de9dc0ccffc9e7652f 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
@@ -489,6 +489,11 @@ bool AudioDeviceDescriptor::IsDistributedSpeaker() const
     return deviceType_ == DEVICE_TYPE_SPEAKER && networkId_ != "LocalDevice";
 }
 
+bool AudioDeviceDescriptor::IsSpeakerOrEarpiece() const
+{
+    return (networkId_ == LOCAL_NETWORK_ID && deviceType_ == DEVICE_TYPE_SPEAKER) || deviceType_ == DEVICE_TYPE_EARPIECE;
+}
+
 bool AudioDeviceDescriptor::IsRemote() const
 {
     return networkId_ != "LocalDevice";
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 83d8814e7b0106e873f61233c7636f70dd63f611..99465f2d7e8c089329e2cfa2047862bfc47006cf 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
@@ -320,6 +320,10 @@ private:
     void CheckModemScene(std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descs,
          const AudioStreamDeviceChangeReasonExt reason);
     int32_t UpdateModemRoute(std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descs);
+    uint32_t GetVoiceCallMuteDuration(AudioDeviceDescriptor &curDesc, AudioDeviceDescriptor &newDesc);
+    void UnmuteVoiceCallAfterMuteDuration(uint32_t muteDuration);
+    void NotifyUnmuteVoiceCall();
+    void SetUpdateModemRouteFinished(bool flag);
     void HandleAudioCaptureState(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo);
     void UpdateDefaultOutputDeviceWhenStopping(int32_t uid);
     void UpdateInputDeviceWhenStopping(int32_t uid);
@@ -576,6 +580,11 @@ private:
     std::unordered_map<uint32_t, sptr<IStandardAudioPolicyManagerListener>> routeUpdateCallback_;
     std::mutex routeUpdateCallbackMutex_;
 
+    std::mutex updateModemRouteMutex_;
+    std::condition_variable updateModemRouteCV_;
+    bool updateModemRouteFinished_ = false;
+    bool needUnmuteVoiceCall_ = false;
+
     DistributedRoutingInfo distributedRoutingInfo_ = {
         .descriptor = nullptr,
         .type = CAST_TYPE_NULL
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 2537820324e6684af930a1d5c84aaf26095707de..05dac1f88f98d65511211f14f73bdd208d16731d 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
@@ -58,6 +58,8 @@ static const int64_t SELECT_DEVICE_MUTE_MS = 200000; // 200ms
 static const int64_t SELECT_OFFLOAD_DEVICE_MUTE_MS = 400000; // 400ms
 static const int64_t OLD_DEVICE_UNAVALIABLE_EXT_MUTE_MS = 300000; // 300ms
 static const int64_t DISTRIBUTED_DEVICE_UNAVALIABLE_MUTE_MS = 1500000;  // 1.5s
+static const uint32_t VOICE_CALL_DEVICE_SWITCH_MUTE_US = 100000; // 100ms
+static const uint32_t MUTE_TO_ROUTE_UPDATE_TIMEOUT_MS = 1000; // 1s
 
 static const uint32_t BASE_DEVICE_SWITCH_SLEEP_US = 80000; // 80ms
 static const uint32_t OLD_DEVICE_UNAVAILABLE_EXTRA_SLEEP_US = 150000; // 150ms
@@ -319,6 +321,11 @@ void AudioCoreService::CheckModemScene(std::vector<std::shared_ptr<AudioDeviceDe
     // and the current output device is different from the target device, then mute to avoid pop issue.
     if (isModemCallRunning && IsDeviceSwitching(reason) && !curDesc.IsSameDeviceDesc(*descs.front())) {
         SetVoiceCallMuteForSwitchDevice();
+        needUnmuteVoiceCall_ = true;
+        SetUpdateModemRouteFinished(false);
+        uint32_t muteDuration = GetVoiceCallMuteDuration(curDesc, *descs.front());
+        std::thread switchThread(&AudioCoreService::UnmuteVoiceCallAfterMuteDuration, this, muteDuration);
+        switchThread.detach();
     }
     CheckAndUpdateHearingAidCall(descs.front()->deviceType_);
 }
@@ -333,7 +340,10 @@ int32_t AudioCoreService::UpdateModemRoute(std::vector<std::shared_ptr<AudioDevi
     if (audioSceneManager_.IsInPhoneCallScene()) {
         audioActiveDevice_.UpdateActiveDeviceRoute(descs.front()->deviceType_, DeviceFlag::OUTPUT_DEVICES_FLAG,
             descs.front()->deviceName_, LOCAL_NETWORK_ID);
-        audioVolumeManager_.SetVoiceCallVolume(GetSystemVolumeLevel(STREAM_VOICE_CALL));
+        if (needUnmuteVoiceCall_) {
+            NotifyUnmuteVoiceCall();
+            needUnmuteVoiceCall_ = false;
+        }
     }
     AudioDeviceDescriptor desc = AudioDeviceDescriptor(descs.front());
     std::unordered_map<uint32_t, std::shared_ptr<AudioStreamDescriptor>> modemSessionMap =
@@ -345,6 +355,44 @@ int32_t AudioCoreService::UpdateModemRoute(std::vector<std::shared_ptr<AudioDevi
     return SUCCESS;
 }
 
+uint32_t AudioCoreService::GetVoiceCallMuteDuration(AudioDeviceDescriptor &curDesc, AudioDeviceDescriptor &newDesc)
+{
+    uint32_t muteDuration = 0;
+    if (!curDesc.IsSameDeviceDesc(newDesc) &&
+        !(curDesc.IsSpeakerOrEarpiece() && newDesc.IsSpeakerOrEarpiece())) {
+        muteDuration = VOICE_CALL_DEVICE_SWITCH_MUTE_US;
+    }
+    return muteDuration;
+}
+
+// muteDuration: duration to keep the voice call muted after modem route update
+void AudioCoreService::UnmuteVoiceCallAfterMuteDuration(uint32_t muteDuration)
+{
+    AUDIO_INFO_LOG("mute voice call %{public}d us after update modem route", muteDuration);
+    {
+        std::unique_lock<std::mutex> lock(updateModemRouteMutex_);
+        updateModemRouteCV_.wait_for(lock, std::chrono::milliseconds(MUTE_TO_ROUTE_UPDATE_TIMEOUT_MS),
+            [this] { return updateModemRouteFinished_; });
+    }
+    usleep(muteDuration);
+    audioVolumeManager_.SetVoiceCallVolume(GetSystemVolumeLevel(STREAM_VOICE_CALL));
+}
+
+void AudioCoreService::NotifyUnmuteVoiceCall()
+{
+    {
+        std::unique_lock<std::mutex> lock(updateModemRouteMutex_);
+        updateModemRouteFinished_ = true;
+    }
+    updateModemRouteCV_.notify_all();
+}
+
+void AudioCoreService::SetUpdateModemRouteFinished(bool flag)
+{
+    std::unique_lock<std::mutex> lock(updateModemRouteMutex_);
+    updateModemRouteFinished_ = flag;
+}
+
 void AudioCoreService::CheckCloseHearingAidCall(const bool isModemCallRunning, const DeviceType type)
 {
     if (hearingAidCallFlag_) {
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 4c07963ff9d4f201858663ca9d59655c5b6b5cc6..7a5b8c678831035a472844b4d4d269b50759f579 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
@@ -2258,10 +2258,16 @@ HWTEST_F(AudioCoreServicePrivateTest, UpdateModemRoute_001, TestSize.Level1)
     EXPECT_NE(audioCoreService->pipeManager_->modemCommunicationIdMap_[0], nullptr);
     std::vector<std::shared_ptr<AudioDeviceDescriptor>> modemDescs =
         audioCoreService->audioRouterCenter_.FetchOutputDevices(STREAM_USAGE_VOICE_MODEM_COMMUNICATION, -1, "");
+
     audioCoreService->audioSceneManager_.audioScene_ = AUDIO_SCENE_PHONE_CALL;
     int32_t ret = audioCoreService->UpdateModemRoute(modemDescs);
-    audioCoreService->audioSceneManager_.audioScene_ = AUDIO_SCENE_DEFAULT;
     EXPECT_EQ(ret, SUCCESS);
+
+    audioCoreService->needUnmuteVoiceCall_ = true;
+    ret = audioCoreService->UpdateModemRoute(modemDescs);
+    EXPECT_EQ(ret, SUCCESS);
+
+    audioCoreService->audioSceneManager_.audioScene_ = AUDIO_SCENE_DEFAULT;
 }
 
 /**
@@ -2285,6 +2291,34 @@ HWTEST_F(AudioCoreServicePrivateTest, UpdateModemRoute_002, TestSize.Level1)
     EXPECT_EQ(ret, SUCCESS);
 }
 
+/**
+ * @tc.name  : Test AudioCoreService.
+ * @tc.number: GetVoiceCallMuteDuration_001
+ * @tc.desc  : Test AudioCoreService::GetVoiceCallMuteDuration
+ */
+HWTEST_F(AudioCoreServicePrivateTest, GetVoiceCallMuteDuration_001, TestSize.Level1)
+{
+    auto audioCoreService = std::make_shared<AudioCoreService>();
+    ASSERT_NE(audioCoreService, nullptr);
+
+    AudioDeviceDescriptor desc1(DeviceType::DEVICE_TYPE_EARPIECE, DeviceRole::OUTPUT_DEVICE);
+    AudioDeviceDescriptor desc2(DeviceType::DEVICE_TYPE_SPEAKER, DeviceRole::OUTPUT_DEVICE);
+    AudioDeviceDescriptor desc3(DeviceType::DEVICE_TYPE_USB_HEADSET, DeviceRole::OUTPUT_DEVICE);
+    uint32_t targetMuteDuration = 100000;
+
+    uint32_t muteDuration = audioCoreService->GetVoiceCallMuteDuration(desc1, desc1);
+    EXPECT_EQ(muteDuration, 0);
+
+    muteDuration = audioCoreService->GetVoiceCallMuteDuration(desc1, desc2);
+    EXPECT_EQ(muteDuration, 0);
+
+    muteDuration = audioCoreService->GetVoiceCallMuteDuration(desc1, desc3);
+    EXPECT_EQ(muteDuration, targetMuteDuration);
+
+    muteDuration = audioCoreService->GetVoiceCallMuteDuration(desc3, desc1);
+    EXPECT_EQ(muteDuration, targetMuteDuration);
+}
+
 /**
  * @tc.name  : Test AudioCoreService.
  * @tc.number: IsStreamSupportLowpower_001